Provided by: liblapack-doc-man_3.6.0-2ubuntu2_all bug

NAME

       complex16_eig - complex16

   Functions
       subroutine zbdt01 (M, N, KD, A, LDA, Q, LDQ, D, E, PT, LDPT, WORK, RWORK, RESID)
           ZBDT01
       subroutine zbdt02 (M, N, B, LDB, C, LDC, U, LDU, WORK, RWORK, RESID)
           ZBDT02
       subroutine zbdt03 (UPLO, N, KD, D, E, U, LDU, S, VT, LDVT, WORK, RESID)
           ZBDT03
       subroutine zchkbb (NSIZES, MVAL, NVAL, NWDTHS, KK, NTYPES, DOTYPE, NRHS, ISEED, THRESH,
           NOUNIT, A, LDA, AB, LDAB, BD, BE, Q, LDQ, P, LDP, C, LDC, CC, WORK, LWORK, RWORK,
           RESULT, INFO)
           ZCHKBB
       subroutine zchkbd (NSIZES, MVAL, NVAL, NTYPES, DOTYPE, NRHS, ISEED, THRESH, A, LDA, BD,
           BE, S1, S2, X, LDX, Y, Z, Q, LDQ, PT, LDPT, U, VT, WORK, LWORK, RWORK, NOUT, INFO)
           ZCHKBD
       subroutine zchkbk (NIN, NOUT)
           ZCHKBK
       subroutine zchkbl (NIN, NOUT)
           ZCHKBL
       subroutine zchkec (THRESH, TSTERR, NIN, NOUT)
           ZCHKEC
       program zchkee
           ZCHKEE
       subroutine zchkgg (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, TSTDIF, THRSHN, NOUNIT, A,
           LDA, B, H, T, S1, S2, P1, P2, U, LDU, V, Q, Z, ALPHA1, BETA1, ALPHA3, BETA3, EVECTL,
           EVECTR, WORK, LWORK, RWORK, LLWORK, RESULT, INFO)
           ZCHKGG
       subroutine zchkgk (NIN, NOUT)
           ZCHKGK
       subroutine zchkgl (NIN, NOUT)
           ZCHKGL
       subroutine zchkhb (NSIZES, NN, NWDTHS, KK, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA,
           SD, SE, U, LDU, WORK, LWORK, RWORK, RESULT, INFO)
           ZCHKHB
       subroutine zchkhs (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, T1, T2,
           U, LDU, Z, UZ, W1, W3, EVECTL, EVECTR, EVECTY, EVECTX, UU, TAU, WORK, NWORK, RWORK,
           IWORK, SELECT, RESULT, INFO)
           ZCHKHS
       subroutine zchkst (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, AP, SD, SE,
           D1, D2, D3, D4, D5, WA1, WA2, WA3, WR, U, LDU, V, VP, TAU, Z, WORK, LWORK, RWORK,
           LRWORK, IWORK, LIWORK, RESULT, INFO)
           ZCHKST
       subroutine zckcsd (NM, MVAL, PVAL, QVAL, NMATS, ISEED, THRESH, MMAX, X, XF, U1, U2, V1T,
           V2T, THETA, IWORK, WORK, RWORK, NIN, NOUT, INFO)
           ZCKCSD
       subroutine zckglm (NN, NVAL, MVAL, PVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, X,
           WORK, RWORK, NIN, NOUT, INFO)
           ZCKGLM
       subroutine zckgqr (NM, MVAL, NP, PVAL, NN, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, AQ,
           AR, TAUA, B, BF, BZ, BT, BWK, TAUB, WORK, RWORK, NIN, NOUT, INFO)
           ZCKGQR
       subroutine zckgsv (NM, MVAL, PVAL, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, U, V,
           Q, ALPHA, BETA, R, IWORK, WORK, RWORK, NIN, NOUT, INFO)
           ZCKGSV
       subroutine zcklse (NN, MVAL, PVAL, NVAL, NMATS, ISEED, THRESH, NMAX, A, AF, B, BF, X,
           WORK, RWORK, NIN, NOUT, INFO)
           ZCKLSE
       subroutine zcsdts (M, P, Q, X, XF, LDX, U1, LDU1, U2, LDU2, V1T, LDV1T, V2T, LDV2T, THETA,
           IWORK, WORK, LWORK, RWORK, RESULT)
           ZCSDTS
       subroutine zdrges (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
           LDQ, Z, ALPHA, BETA, WORK, LWORK, RWORK, RESULT, BWORK, INFO)
           ZDRGES
       subroutine zdrges3 (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
           LDQ, Z, ALPHA, BETA, WORK, LWORK, RWORK, RESULT, BWORK, INFO)
           ZDRGES3
       subroutine zdrgev (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
           LDQ, Z, QE, LDQE, ALPHA, BETA, ALPHA1, BETA1, WORK, LWORK, RWORK, RESULT, INFO)
           ZDRGEV
       subroutine zdrgev3 (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, S, T, Q,
           LDQ, Z, QE, LDQE, ALPHA, BETA, ALPHA1, BETA1, WORK, LWORK, RWORK, RESULT, INFO)
           ZDRGEV3
       subroutine zdrgsx (NSIZE, NCMAX, THRESH, NIN, NOUT, A, LDA, B, AI, BI, Z, Q, ALPHA, BETA,
           C, LDC, S, WORK, LWORK, RWORK, IWORK, LIWORK, BWORK, INFO)
           ZDRGSX
       subroutine zdrgvx (NSIZE, THRESH, NIN, NOUT, A, LDA, B, AI, BI, ALPHA, BETA, VL, VR, ILO,
           IHI, LSCALE, RSCALE, S, DTRU, DIF, DIFTRU, WORK, LWORK, RWORK, IWORK, LIWORK, RESULT,
           BWORK, INFO)
           ZDRGVX
       subroutine zdrvbd (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)
           ZDRVBD
       subroutine zdrves (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, HT, W,
           WT, VS, LDVS, RESULT, WORK, NWORK, RWORK, IWORK, BWORK, INFO)
           ZDRVES
       subroutine zdrvev (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, H, W, W1,
           VL, LDVL, VR, LDVR, LRE, LDLRE, RESULT, WORK, NWORK, RWORK, IWORK, INFO)
           ZDRVEV
       subroutine zdrvsg (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, B, LDB, D,
           Z, LDZ, AB, BB, AP, BP, WORK, NWORK, RWORK, LRWORK, IWORK, LIWORK, RESULT, INFO)
           ZDRVSG
       subroutine zdrvst (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NOUNIT, A, LDA, D1, D2, D3,
           WA1, WA2, WA3, U, LDU, V, TAU, Z, WORK, LWORK, RWORK, LRWORK, IWORK, LIWORK, RESULT,
           INFO)
           ZDRVST
       subroutine zdrvsx (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NIUNIT, NOUNIT, A, LDA, H,
           HT, W, WT, WTMP, VS, LDVS, VS1, RESULT, WORK, LWORK, RWORK, BWORK, INFO)
           ZDRVSX
       subroutine zdrvvx (NSIZES, NN, NTYPES, DOTYPE, ISEED, THRESH, NIUNIT, NOUNIT, A, LDA, H,
           W, W1, VL, LDVL, VR, LDVR, LRE, LDLRE, RCONDV, RCNDV1, RCDVIN, RCONDE, RCNDE1, RCDEIN,
           SCALE, SCALE1, RESULT, WORK, NWORK, RWORK, INFO)
           ZDRVVX
       subroutine zerrbd (PATH, NUNIT)
           ZERRBD
       subroutine zerrec (PATH, NUNIT)
           ZERREC
       subroutine zerred (PATH, NUNIT)
           ZERRED
       subroutine zerrgg (PATH, NUNIT)
           ZERRGG
       subroutine zerrhs (PATH, NUNIT)
           ZERRHS
       subroutine zerrst (PATH, NUNIT)
           ZERRST
       subroutine zget02 (TRANS, M, N, NRHS, A, LDA, X, LDX, B, LDB, RWORK, RESID)
           ZGET02
       subroutine zget10 (M, N, A, LDA, B, LDB, WORK, RWORK, RESULT)
           ZGET10
       subroutine zget22 (TRANSA, TRANSE, TRANSW, N, A, LDA, E, LDE, W, WORK, RWORK, RESULT)
           ZGET22
       subroutine zget23 (COMP, ISRT, BALANC, JTYPE, THRESH, ISEED, NOUNIT, N, A, LDA, H, W, W1,
           VL, LDVL, VR, LDVR, LRE, LDLRE, RCONDV, RCNDV1, RCDVIN, RCONDE, RCNDE1, RCDEIN, SCALE,
           SCALE1, RESULT, WORK, LWORK, RWORK, INFO)
           ZGET23
       subroutine zget24 (COMP, JTYPE, THRESH, ISEED, NOUNIT, N, A, LDA, H, HT, W, WT, WTMP, VS,
           LDVS, VS1, RCDEIN, RCDVIN, NSLCT, ISLCT, ISRT, RESULT, WORK, LWORK, RWORK, BWORK,
           INFO)
           ZGET24
       subroutine zget35 (RMAX, LMAX, NINFO, KNT, NIN)
           ZGET35
       subroutine zget36 (RMAX, LMAX, NINFO, KNT, NIN)
           ZGET36
       subroutine zget37 (RMAX, LMAX, NINFO, KNT, NIN)
           ZGET37
       subroutine zget38 (RMAX, LMAX, NINFO, KNT, NIN)
           ZGET38
       subroutine zget51 (ITYPE, N, A, LDA, B, LDB, U, LDU, V, LDV, WORK, RWORK, RESULT)
           ZGET51
       subroutine zget52 (LEFT, N, A, LDA, B, LDB, E, LDE, ALPHA, BETA, WORK, RWORK, RESULT)
           ZGET52
       subroutine zget54 (N, A, LDA, B, LDB, S, LDS, T, LDT, U, LDU, V, LDV, WORK, RESULT)
           ZGET54
       subroutine zglmts (N, M, P, A, AF, LDA, B, BF, LDB, D, DF, X, U, WORK, LWORK, RWORK,
           RESULT)
           ZGLMTS
       subroutine zgqrts (N, M, P, A, AF, Q, R, LDA, TAUA, B, BF, Z, T, BWK, LDB, TAUB, WORK,
           LWORK, RWORK, RESULT)
           ZGQRTS
       subroutine zgrqts (M, P, N, A, AF, Q, R, LDA, TAUA, B, BF, Z, T, BWK, LDB, TAUB, WORK,
           LWORK, RWORK, RESULT)
           ZGRQTS
       subroutine zgsvts3 (M, P, N, A, AF, LDA, B, BF, LDB, U, LDU, V, LDV, Q, LDQ, ALPHA, BETA,
           R, LDR, IWORK, WORK, LWORK, RWORK, RESULT)
           ZGSVTS3
       subroutine zhbt21 (UPLO, N, KA, KS, A, LDA, D, E, U, LDU, WORK, RWORK, RESULT)
           ZHBT21
       subroutine zhet21 (ITYPE, UPLO, N, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK, RWORK,
           RESULT)
           ZHET21
       subroutine zhet22 (ITYPE, UPLO, N, M, KBAND, A, LDA, D, E, U, LDU, V, LDV, TAU, WORK,
           RWORK, RESULT)
           ZHET22
       subroutine zhpt21 (ITYPE, UPLO, N, KBAND, AP, D, E, U, LDU, VP, TAU, WORK, RWORK, RESULT)
           ZHPT21
       subroutine zhst01 (N, ILO, IHI, A, LDA, H, LDH, Q, LDQ, WORK, LWORK, RWORK, RESULT)
           ZHST01
       subroutine zlarfy (UPLO, N, V, INCV, TAU, C, LDC, WORK)
           ZLARFY
       subroutine zlarhs (PATH, XTYPE, UPLO, TRANS, M, N, KL, KU, NRHS, A, LDA, X, LDX, B, LDB,
           ISEED, INFO)
           ZLARHS
       subroutine zlatm4 (ITYPE, N, NZ1, NZ2, RSIGN, AMAGN, RCOND, TRIANG, IDIST, ISEED, A, LDA)
           ZLATM4
       logical function zlctes (Z, D)
           ZLCTES
       logical function zlctsx (ALPHA, BETA)
           ZLCTSX
       subroutine zlsets (M, P, N, A, AF, LDA, B, BF, LDB, C, CF, D, DF, X, WORK, LWORK, RWORK,
           RESULT)
           ZLSETS
       subroutine zsbmv (UPLO, N, K, ALPHA, A, LDA, X, INCX, BETA, Y, INCY)
           ZSBMV
       subroutine zsgt01 (ITYPE, UPLO, N, M, A, LDA, B, LDB, Z, LDZ, D, WORK, RWORK, RESULT)
           ZSGT01
       logical function zslect (Z)
           ZSLECT
       subroutine zstt21 (N, KBAND, AD, AE, SD, SE, U, LDU, WORK, RWORK, RESULT)
           ZSTT21
       subroutine zstt22 (N, M, KBAND, AD, AE, SD, SE, U, LDU, WORK, LDWORK, RWORK, RESULT)
           ZSTT22
       subroutine zunt01 (ROWCOL, M, N, U, LDU, WORK, LWORK, RWORK, RESID)
           ZUNT01
       subroutine zunt03 (RC, MU, MV, N, K, U, LDU, V, LDV, WORK, LWORK, RWORK, RESULT, INFO)
           ZUNT03

Detailed Description

       This is the group of complex16 LAPACK TESTING EIG routines.

Function Documentation

   subroutine zbdt01 (integer M, integer N, integer KD, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldq, * ) Q, integer LDQ, double precision, dimension(
       * ) D, double precision, dimension( * ) E, complex*16, dimension( ldpt, * ) PT, integer
       LDPT, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, double
       precision RESID)
       ZBDT01

       Purpose:

            ZBDT01 reconstructs a general matrix A from its bidiagonal form
               A = Q * B * P'
            where Q (m by min(m,n)) and P' (min(m,n) by n) are unitary
            matrices and B is bidiagonal.

            The test ratio to test the reduction is
               RESID = norm( A - Q * B * PT ) / ( n * norm(A) * EPS )
            where PT = P' and EPS is the machine precision.

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrices A and Q.

           N

                     N is INTEGER
                     The number of columns of the matrices A and P'.

           KD

                     KD is INTEGER
                     If KD = 0, B is diagonal and the array E is not referenced.
                     If KD = 1, the reduction was performed by xGEBRD; B is upper
                     bidiagonal if M >= N, and lower bidiagonal if M < N.
                     If KD = -1, the reduction was performed by xGBBRD; B is
                     always upper bidiagonal.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m by n matrix A.

           LDA

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

           Q

                     Q is COMPLEX*16 array, dimension (LDQ,N)
                     The m by min(m,n) unitary matrix Q in the reduction
                     A = Q * B * P'.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.  LDQ >= max(1,M).

           D

                     D is DOUBLE PRECISION array, dimension (min(M,N))
                     The diagonal elements of the bidiagonal matrix B.

           E

                     E is DOUBLE PRECISION array, dimension (min(M,N)-1)
                     The superdiagonal elements of the bidiagonal matrix B if
                     m >= n, or the subdiagonal elements of B if m < n.

           PT

                     PT is COMPLEX*16 array, dimension (LDPT,N)
                     The min(m,n) by n unitary matrix P' in the reduction
                     A = Q * B * P'.

           LDPT

                     LDPT is INTEGER
                     The leading dimension of the array PT.
                     LDPT >= max(1,min(M,N)).

           WORK

                     WORK is COMPLEX*16 array, dimension (M+N)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESID

                     RESID is DOUBLE PRECISION
                     The test ratio:  norm(A - Q * B * P') / ( n * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zbdt02 (integer M, integer N, complex*16, dimension( ldb, * ) B, integer LDB,
       complex*16, dimension( ldc, * ) C, integer LDC, complex*16, dimension( ldu, * ) U, integer
       LDU, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, double
       precision RESID)
       ZBDT02

       Purpose:

            ZBDT02 tests the change of basis C = U' * B by computing the residual

               RESID = norm( B - U * C ) / ( max(m,n) * norm(B) * EPS ),

            where B and C are M by N matrices, U is an M by M orthogonal matrix,
            and EPS is the machine precision.

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrices B and C and the order of
                     the matrix Q.

           N

                     N is INTEGER
                     The number of columns of the matrices B and C.

           B

                     B is COMPLEX*16 array, dimension (LDB,N)
                     The m by n matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,M).

           C

                     C is COMPLEX*16 array, dimension (LDC,N)
                     The m by n matrix C, assumed to contain U' * B.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C.  LDC >= max(1,M).

           U

                     U is COMPLEX*16 array, dimension (LDU,M)
                     The m by m orthogonal matrix U.

           LDU

                     LDU is INTEGER
                     The leading dimension of the array U.  LDU >= max(1,M).

           WORK

                     WORK is COMPLEX*16 array, dimension (M)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESID

                     RESID is DOUBLE PRECISION
                     RESID = norm( B - U * C ) / ( max(m,n) * norm(B) * EPS ),

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zbdt03 (character UPLO, integer N, integer KD, double precision, dimension( * ) D,
       double precision, dimension( * ) E, complex*16, dimension( ldu, * ) U, integer LDU, double
       precision, dimension( * ) S, complex*16, dimension( ldvt, * ) VT, integer LDVT,
       complex*16, dimension( * ) WORK, double precision RESID)
       ZBDT03

       Purpose:

            ZBDT03 reconstructs a bidiagonal matrix B from its SVD:
               S = U' * B * V
            where U and V are orthogonal matrices and S is diagonal.

            The test ratio to test the singular value decomposition is
               RESID = norm( B - U * S * VT ) / ( n * norm(B) * EPS )
            where VT = V' and EPS is the machine precision.

       Parameters:
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the matrix B is upper or lower bidiagonal.
                     = 'U':  Upper bidiagonal
                     = 'L':  Lower bidiagonal

           N

                     N is INTEGER
                     The order of the matrix B.

           KD

                     KD is INTEGER
                     The bandwidth of the bidiagonal matrix B.  If KD = 1, the
                     matrix B is bidiagonal, and if KD = 0, B is diagonal and E is
                     not referenced.  If KD is greater than 1, it is assumed to be
                     1, and if KD is less than 0, it is assumed to be 0.

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The n diagonal elements of the bidiagonal matrix B.

           E

                     E is DOUBLE PRECISION array, dimension (N-1)
                     The (n-1) superdiagonal elements of the bidiagonal matrix B
                     if UPLO = 'U', or the (n-1) subdiagonal elements of B if
                     UPLO = 'L'.

           U

                     U is COMPLEX*16 array, dimension (LDU,N)
                     The n by n orthogonal matrix U in the reduction B = U'*A*P.

           LDU

                     LDU is INTEGER
                     The leading dimension of the array U.  LDU >= max(1,N)

           S

                     S is DOUBLE PRECISION array, dimension (N)
                     The singular values from the SVD of B, sorted in decreasing
                     order.

           VT

                     VT is COMPLEX*16 array, dimension (LDVT,N)
                     The n by n orthogonal matrix V' in the reduction
                     B = U * S * V'.

           LDVT

                     LDVT is INTEGER
                     The leading dimension of the array VT.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N)

           RESID

                     RESID is DOUBLE PRECISION
                     The test ratio:  norm(B - U * S * V') / ( n * norm(A) * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkbb (integer NSIZES, integer, dimension( * ) MVAL, integer, dimension( * ) NVAL,
       integer NWDTHS, integer, dimension( * ) KK, integer NTYPES, logical, dimension( * )
       DOTYPE, integer NRHS, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldab, * )
       AB, integer LDAB, double precision, dimension( * ) BD, double precision, dimension( * )
       BE, complex*16, dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldp, * ) P,
       integer LDP, complex*16, dimension( ldc, * ) C, integer LDC, complex*16, dimension( ldc, *
       ) CC, complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * )
       RWORK, double precision, dimension( * ) RESULT, integer INFO)
       ZCHKBB

       Purpose:

            ZCHKBB tests the reduction of a general complex rectangular band
            matrix to real bidiagonal form.

            ZGBBRD factors a general band matrix A as  Q B P* , where * means
            conjugate transpose, B is upper bidiagonal, and Q and P are unitary;
            ZGBBRD can also overwrite a given matrix C with Q* C .

            For each pair of matrix dimensions (M,N) and each selected matrix
            type, an M by N matrix A and an M by NRHS matrix C are generated.
            The problem dimensions are as follows
               A:          M x N
               Q:          M x M
               P:          N x N
               B:          min(M,N) x min(M,N)
               C:          M x NRHS

            For each generated matrix, 4 tests are performed:

            (1)   | A - Q B PT | / ( |A| max(M,N) ulp ), PT = P'

            (2)   | I - Q' Q | / ( M ulp )

            (3)   | I - PT PT' | / ( N ulp )

            (4)   | Y - Q' C | / ( |Y| max(M,NRHS) ulp ), where Y = Q' C.

            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:

            The possible matrix types are

            (1)  The zero matrix.
            (2)  The identity matrix.

            (3)  A diagonal matrix with evenly spaced entries
                 1, ..., ULP  and random signs.
                 (ULP = (first number larger than 1) - 1 )
            (4)  A diagonal matrix with geometrically spaced entries
                 1, ..., ULP  and random signs.
            (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                 and random signs.

            (6)  Same as (3), but multiplied by SQRT( overflow threshold )
            (7)  Same as (3), but multiplied by SQRT( underflow threshold )

            (8)  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.

            (9)  A matrix of the form  U D V, where U and V are orthogonal and
                 D has geometrically spaced entries 1, ..., ULP with random
                 signs on the diagonal.

            (10) A matrix of the form  U D V, where U and V are orthogonal and
                 D has "clustered" entries 1, ULP,..., ULP with random
                 signs on the diagonal.

            (11) Same as (8), but multiplied by SQRT( overflow threshold )
            (12) Same as (8), but multiplied by SQRT( underflow threshold )

            (13) Rectangular matrix with random entries chosen from (-1,1).
            (14) Same as (13), but multiplied by SQRT( overflow threshold )
            (15) Same as (13), but multiplied by SQRT( underflow threshold )

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of values of M and N contained in the vectors
                     MVAL and NVAL.  The matrix sizes are used in pairs (M,N).
                     If NSIZES is zero, ZCHKBB does nothing.  NSIZES must be at
                     least zero.

           MVAL

                     MVAL is INTEGER array, dimension (NSIZES)
                     The values of the matrix row dimension M.

           NVAL

                     NVAL is INTEGER array, dimension (NSIZES)
                     The values of the matrix column dimension N.

           NWDTHS

                     NWDTHS is INTEGER
                     The number of bandwidths to use.  If it is zero,
                     ZCHKBB does nothing.  It must be at least zero.

           KK

                     KK is INTEGER array, dimension (NWDTHS)
                     An array containing the bandwidths to be used for the band
                     matrices.  The values must be at least zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZCHKBB
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           NRHS

                     NRHS is INTEGER
                     The number of columns in the "right-hand side" matrix C.
                     If NRHS = 0, then the operations on the right-hand side will
                     not be tested. NRHS must be at least 0.

           ISEED

                     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 ZCHKBB to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           A

                     A is DOUBLE PRECISION array, dimension
                                       (LDA, max(NN))
                     Used to hold the matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at least 1
                     and at least max( NN ).

           AB

                     AB is DOUBLE PRECISION array, dimension (LDAB, max(NN))
                     Used to hold A in band storage format.

           LDAB

                     LDAB is INTEGER
                     The leading dimension of AB.  It must be at least 2 (not 1!)
                     and at least max( KK )+1.

           BD

                     BD is DOUBLE PRECISION array, dimension (max(NN))
                     Used to hold the diagonal of the bidiagonal matrix computed
                     by ZGBBRD.

           BE

                     BE is DOUBLE PRECISION array, dimension (max(NN))
                     Used to hold the off-diagonal of the bidiagonal matrix
                     computed by ZGBBRD.

           Q

                     Q is COMPLEX*16 array, dimension (LDQ, max(NN))
                     Used to hold the unitary matrix Q computed by ZGBBRD.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of Q.  It must be at least 1
                     and at least max( NN ).

           P

                     P is COMPLEX*16 array, dimension (LDP, max(NN))
                     Used to hold the unitary matrix P computed by ZGBBRD.

           LDP

                     LDP is INTEGER
                     The leading dimension of P.  It must be at least 1
                     and at least max( NN ).

           C

                     C is COMPLEX*16 array, dimension (LDC, max(NN))
                     Used to hold the matrix C updated by ZGBBRD.

           LDC

                     LDC is INTEGER
                     The leading dimension of U.  It must be at least 1
                     and at least max( NN ).

           CC

                     CC is COMPLEX*16 array, dimension (LDC, max(NN))
                     Used to hold a copy of the matrix C.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     max( LDA+1, max(NN)+1 )*max(NN).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(NN))

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           INFO

                     INFO is INTEGER
                     If 0, then everything ran OK.

           -----------------------------------------------------------------------

                  Some Local Variables and Parameters:
                  ---- ----- --------- --- ----------
                  ZERO, ONE       Real 0 and 1.
                  MAXTYP          The number of types defined.
                  NTEST           The number of tests performed, or which can
                                  be performed so far, for the current matrix.
                  NTESTT          The total number of tests performed so far.
                  NMAX            Largest value in NN.
                  NMATS           The number of matrices generated so far.
                  NERRS           The number of tests which have exceeded THRESH
                                  so far.
                  COND, IMODE     Values to be passed to the matrix generators.
                  ANORM           Norm of A; passed to matrix generators.

                  OVFL, UNFL      Overflow and underflow thresholds.
                  ULP, ULPINV     Finest relative precision and its inverse.
                  RTOVFL, RTUNFL  Square roots of the previous 2 values.
                          The following four arrays decode JTYPE:
                  KTYPE(j)        The general type (1-10) for type "j".
                  KMODE(j)        The MODE value to be passed to the matrix
                                  generator for type "j".
                  KMAGN(j)        The order of magnitude ( O(1),
                                  O(overflow^(1/2) ), O(underflow^(1/2) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkbd (integer NSIZES, integer, dimension( * ) MVAL, integer, dimension( * ) NVAL,
       integer NTYPES, logical, dimension( * ) DOTYPE, integer NRHS, integer, dimension( 4 )
       ISEED, double precision THRESH, complex*16, dimension( lda, * ) A, integer LDA, double
       precision, dimension( * ) BD, double precision, dimension( * ) BE, double precision,
       dimension( * ) S1, double precision, dimension( * ) S2, complex*16, dimension( ldx, * ) X,
       integer LDX, complex*16, dimension( ldx, * ) Y, complex*16, dimension( ldx, * ) Z,
       complex*16, dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldpt, * ) PT,
       integer LDPT, complex*16, dimension( ldpt, * ) U, complex*16, dimension( ldpt, * ) VT,
       complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK,
       integer NOUT, integer INFO)
       ZCHKBD

       Purpose:

            ZCHKBD checks the singular value decomposition (SVD) routines.

            ZGEBRD reduces a complex general m by n matrix A to real upper or
            lower bidiagonal form by an orthogonal transformation: Q' * A * P = B
            (or A = Q * B * P').  The matrix B is upper bidiagonal if m >= n
            and lower bidiagonal if m < n.

            ZUNGBR generates the orthogonal matrices Q and P' from ZGEBRD.
            Note that Q and P are not necessarily square.

            ZBDSQR computes the singular value decomposition of the bidiagonal
            matrix B as B = U S V'.  It is called three times to compute
               1)  B = U S1 V', where S1 is the diagonal matrix of singular
                   values and the columns of the matrices U and V are the left
                   and right singular vectors, respectively, of B.
               2)  Same as 1), but the singular values are stored in S2 and the
                   singular vectors are not computed.
               3)  A = (UQ) S (P'V'), the SVD of the original matrix A.
            In addition, ZBDSQR has an option to apply the left orthogonal matrix
            U to a matrix X, useful in least squares applications.

            For each pair of matrix dimensions (M,N) and each selected matrix
            type, an M by N matrix A and an M by NRHS matrix X are generated.
            The problem dimensions are as follows
               A:          M x N
               Q:          M x min(M,N) (but M x M if NRHS > 0)
               P:          min(M,N) x N
               B:          min(M,N) x min(M,N)
               U, V:       min(M,N) x min(M,N)
               S1, S2      diagonal, order min(M,N)
               X:          M x NRHS

            For each generated matrix, 14 tests are performed:

            Test ZGEBRD and ZUNGBR

            (1)   | A - Q B PT | / ( |A| max(M,N) ulp ), PT = P'

            (2)   | I - Q' Q | / ( M ulp )

            (3)   | I - PT PT' | / ( N ulp )

            Test ZBDSQR on bidiagonal matrix B

            (4)   | B - U S1 VT | / ( |B| min(M,N) ulp ), VT = V'

            (5)   | Y - U Z | / ( |Y| max(min(M,N),k) ulp ), where Y = Q' X
                                                             and   Z = U' Y.
            (6)   | I - U' U | / ( min(M,N) ulp )

            (7)   | I - VT VT' | / ( min(M,N) ulp )

            (8)   S1 contains min(M,N) nonnegative values in decreasing order.
                  (Return 0 if true, 1/ULP if false.)

            (9)   0 if the true singular values of B are within THRESH of
                  those in S1.  2*THRESH if they are not.  (Tested using
                  DSVDCH)

            (10)  | S1 - S2 | / ( |S1| ulp ), where S2 is computed without
                                              computing U and V.

            Test ZBDSQR on matrix A

            (11)  | A - (QU) S (VT PT) | / ( |A| max(M,N) ulp )

            (12)  | X - (QU) Z | / ( |X| max(M,k) ulp )

            (13)  | I - (QU)'(QU) | / ( M ulp )

            (14)  | I - (VT PT) (PT'VT') | / ( N ulp )

            The possible matrix types are

            (1)  The zero matrix.
            (2)  The identity matrix.

            (3)  A diagonal matrix with evenly spaced entries
                 1, ..., ULP  and random signs.
                 (ULP = (first number larger than 1) - 1 )
            (4)  A diagonal matrix with geometrically spaced entries
                 1, ..., ULP  and random signs.
            (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                 and random signs.

            (6)  Same as (3), but multiplied by SQRT( overflow threshold )
            (7)  Same as (3), but multiplied by SQRT( underflow threshold )

            (8)  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.

            (9)  A matrix of the form  U D V, where U and V are orthogonal and
                 D has geometrically spaced entries 1, ..., ULP with random
                 signs on the diagonal.

            (10) A matrix of the form  U D V, where U and V are orthogonal and
                 D has "clustered" entries 1, ULP,..., ULP with random
                 signs on the diagonal.

            (11) Same as (8), but multiplied by SQRT( overflow threshold )
            (12) Same as (8), but multiplied by SQRT( underflow threshold )

            (13) Rectangular matrix with random entries chosen from (-1,1).
            (14) Same as (13), but multiplied by SQRT( overflow threshold )
            (15) Same as (13), but multiplied by SQRT( underflow threshold )

            Special case:
            (16) A bidiagonal matrix with random entries chosen from a
                 logarithmic distribution on [ulp^2,ulp^(-2)]  (I.e., each
                 entry is  e^x, where x is chosen uniformly on
                 [ 2 log(ulp), -2 log(ulp) ] .)  For *this* type:
                 (a) ZGEBRD is not called to reduce it to bidiagonal form.
                 (b) the bidiagonal is  min(M,N) x min(M,N); if M<N, the
                     matrix will be lower bidiagonal, otherwise upper.
                 (c) only tests 5--8 and 14 are performed.

            A subset of the full set of matrix types may be selected through
            the logical array DOTYPE.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of values of M and N contained in the vectors
                     MVAL and NVAL.  The matrix sizes are used in pairs (M,N).

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           NVAL

                     NVAL is INTEGER array, dimension (NM)
                     The values of the matrix column dimension N.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZCHKBD
                     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. .

           DOTYPE

                     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.

           NRHS

                     NRHS is INTEGER
                     The number of columns in the "right-hand side" matrices X, Y,
                     and Z, used in testing ZBDSQR.  If NRHS = 0, then the
                     operations on the right-hand side will not be tested.
                     NRHS must be at least 0.

           ISEED

                     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 values of ISEED are changed on exit, and can be
                     used in the next call to ZCHKBD to continue the same random
                     number sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.  Note that the
                     expected value of the test ratios is O(1), so THRESH should
                     be a reasonably small multiple of 1, e.g., 10 or 100.

           A

                     A is COMPLEX*16 array, dimension (LDA,NMAX)
                     where NMAX is the maximum value of N in NVAL.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.  LDA >= max(1,MMAX),
                     where MMAX is the maximum value of M in MVAL.

           BD

                     BD is DOUBLE PRECISION array, dimension
                                 (max(min(MVAL(j),NVAL(j))))

           BE

                     BE is DOUBLE PRECISION array, dimension
                                 (max(min(MVAL(j),NVAL(j))))

           S1

                     S1 is DOUBLE PRECISION array, dimension
                                 (max(min(MVAL(j),NVAL(j))))

           S2

                     S2 is DOUBLE PRECISION array, dimension
                                 (max(min(MVAL(j),NVAL(j))))

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)

           LDX

                     LDX is INTEGER
                     The leading dimension of the arrays X, Y, and Z.
                     LDX >= max(1,MMAX).

           Y

                     Y is COMPLEX*16 array, dimension (LDX,NRHS)

           Z

                     Z is COMPLEX*16 array, dimension (LDX,NRHS)

           Q

                     Q is COMPLEX*16 array, dimension (LDQ,MMAX)

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.  LDQ >= max(1,MMAX).

           PT

                     PT is COMPLEX*16 array, dimension (LDPT,NMAX)

           LDPT

                     LDPT is INTEGER
                     The leading dimension of the arrays PT, U, and V.
                     LDPT >= max(1, max(min(MVAL(j),NVAL(j)))).

           U

                     U is COMPLEX*16 array, dimension
                                 (LDPT,max(min(MVAL(j),NVAL(j))))

           VT

                     VT is COMPLEX*16 array, dimension
                                 (LDPT,max(min(MVAL(j),NVAL(j))))

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     3(M+N) and  M(M + max(M,N,k) + 1) + N*min(M,N)  for all
                     pairs  (M,N)=(MM(j),NN(j))

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension
                                 (5*max(min(M,N)))

           NOUT

                     NOUT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           INFO

                     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
                      -6: NRHS  < 0
                      -8: THRESH < 0
                     -11: LDA < 1 or LDA < MMAX, where MMAX is max( MM(j) ).
                     -17: LDB < 1 or LDB < MMAX.
                     -21: LDQ < 1 or LDQ < MMAX.
                     -23: LDP < 1 or LDP < MNMAX.
                     -27: LWORK too small.
                     If  ZLATMR, CLATMS, ZGEBRD, ZUNGBR, or ZBDSQR,
                         returns an error code, the
                         absolute value of it is returned.

           -----------------------------------------------------------------------

                Some Local Variables and Parameters:
                ---- ----- --------- --- ----------

                ZERO, ONE       Real 0 and 1.
                MAXTYP          The number of types defined.
                NTEST           The number of tests performed, or which can
                                be performed so far, for the current matrix.
                MMAX            Largest value in NN.
                NMAX            Largest value in NN.
                MNMIN           min(MM(j), NN(j)) (the dimension of the bidiagonal
                                matrix.)
                MNMAX           The maximum value of MNMIN for j=1,...,NSIZES.
                NFAIL           The number of tests which have exceeded THRESH
                COND, IMODE     Values to be passed to the matrix generators.
                ANORM           Norm of A; passed to matrix generators.

                OVFL, UNFL      Overflow and underflow thresholds.
                RTOVFL, RTUNFL  Square roots of the previous 2 values.
                ULP, ULPINV     Finest relative precision and its inverse.

                        The following four arrays decode JTYPE:
                KTYPE(j)        The general type (1-10) for type "j".
                KMODE(j)        The MODE value to be passed to the matrix
                                generator for type "j".
                KMAGN(j)        The order of magnitude ( O(1),
                                O(overflow^(1/2) ), O(underflow^(1/2) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkbk (integer NIN, integer NOUT)
       ZCHKBK

       Purpose:

            ZCHKBK tests ZGEBAK, a routine for backward transformation of
            the computed right or left eigenvectors if the orginal matrix
            was preprocessed by balance subroutine ZGEBAL.

       Parameters:
           NIN

                     NIN is INTEGER
                     The logical unit number for input.  NIN > 0.

           NOUT

                     NOUT is INTEGER
                     The logical unit number for output.  NOUT > 0.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkbl (integer NIN, integer NOUT)
       ZCHKBL

       Purpose:

            ZCHKBL tests ZGEBAL, a routine for balancing a general complex
            matrix and isolating some of its eigenvalues.

       Parameters:
           NIN

                     NIN is INTEGER
                     The logical unit number for input.  NIN > 0.

           NOUT

                     NOUT is INTEGER
                     The logical unit number for output.  NOUT > 0.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkec (double precision THRESH, logical TSTERR, integer NIN, integer NOUT)
       ZCHKEC

       Purpose:

            ZCHKEC tests eigen- condition estimation routines
                   ZTRSYL, CTREXC, CTRSNA, CTRSEN

            In all cases, the routine runs through a fixed set of numerical
            examples, subjects them to various tests, and compares the test
            results to a threshold THRESH. In addition, ZTRSNA and CTRSEN are
            tested by reading in precomputed examples from a file (on input unit
            NIN).  Output is written to output unit NOUT.

       Parameters:
           THRESH

                     THRESH is DOUBLE PRECISION
                     Threshold for residual tests.  A computed test ratio passes
                     the threshold if it is less than THRESH.

           TSTERR

                     TSTERR is LOGICAL
                     Flag that indicates whether error exits are to be tested.

           NIN

                     NIN is INTEGER
                     The logical unit number for input.

           NOUT

                     NOUT is INTEGER
                     The logical unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           September 2012

   program zchkee ()
       ZCHKEE

       Purpose:

            ZCHKEE tests the COMPLEX*16 LAPACK subroutines for the matrix
            eigenvalue problem.  The test paths in this version are

            NEP (Nonsymmetric Eigenvalue Problem):
                Test ZGEHRD, ZUNGHR, ZHSEQR, ZTREVC, ZHSEIN, and ZUNMHR

            SEP (Hermitian Eigenvalue Problem):
                Test ZHETRD, ZUNGTR, ZSTEQR, ZSTERF, ZSTEIN, ZSTEDC,
                and drivers ZHEEV(X), ZHBEV(X), ZHPEV(X),
                            ZHEEVD,   ZHBEVD,   ZHPEVD

            SVD (Singular Value Decomposition):
                Test ZGEBRD, ZUNGBR, and ZBDSQR
                and the drivers ZGESVD, ZGESDD

            ZEV (Nonsymmetric Eigenvalue/eigenvector Driver):
                Test ZGEEV

            ZES (Nonsymmetric Schur form Driver):
                Test ZGEES

            ZVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver):
                Test ZGEEVX

            ZSX (Nonsymmetric Schur form Expert Driver):
                Test ZGEESX

            ZGG (Generalized Nonsymmetric Eigenvalue Problem):
                Test ZGGHD3, ZGGBAL, ZGGBAK, ZHGEQZ, and ZTGEVC

            ZGS (Generalized Nonsymmetric Schur form Driver):
                Test ZGGES

            ZGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver):
                Test ZGGEV

            ZGX (Generalized Nonsymmetric Schur form Expert Driver):
                Test ZGGESX

            ZXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver):
                Test ZGGEVX

            ZSG (Hermitian Generalized Eigenvalue Problem):
                Test ZHEGST, ZHEGV, ZHEGVD, ZHEGVX, ZHPGST, ZHPGV, ZHPGVD,
                ZHPGVX, ZHBGST, ZHBGV, ZHBGVD, and ZHBGVX

            ZHB (Hermitian Band Eigenvalue Problem):
                Test ZHBTRD

            ZBB (Band Singular Value Decomposition):
                Test ZGBBRD

            ZEC (Eigencondition estimation):
                Test ZTRSYL, ZTREXC, ZTRSNA, and ZTRSEN

            ZBL (Balancing a general matrix)
                Test ZGEBAL

            ZBK (Back transformation on a balanced matrix)
                Test ZGEBAK

            ZGL (Balancing a matrix pair)
                Test ZGGBAL

            ZGK (Back transformation on a matrix pair)
                Test ZGGBAK

            GLM (Generalized Linear Regression Model):
                Tests ZGGGLM

            GQR (Generalized QR and RQ factorizations):
                Tests ZGGQRF and ZGGRQF

            GSV (Generalized Singular Value Decomposition):
                Tests ZGGSVD, ZGGSVP, ZTGSJA, ZLAGS2, ZLAPLL, and ZLAPMT

            CSD (CS decomposition):
                Tests ZUNCSD

            LSE (Constrained Linear Least Squares):
                Tests ZGGLSE

            Each test path has a different set of inputs, but the data sets for
            the driver routines xEV, xES, xVX, and xSX can be concatenated in a
            single input file.  The first line of input should contain one of the
            3-character path names in columns 1-3.  The number of remaining lines
            depends on what is found on the first line.

            The number of matrix types used in testing is often controllable from
            the input file.  The number of matrix types for each path, and the
            test routine that describes them, is as follows:

            Path name(s)  Types    Test routine

            ZHS or NEP      21     ZCHKHS
            ZST or SEP      21     ZCHKST (routines)
                            18     ZDRVST (drivers)
            ZBD or SVD      16     ZCHKBD (routines)
                             5     ZDRVBD (drivers)
            ZEV             21     ZDRVEV
            ZES             21     ZDRVES
            ZVX             21     ZDRVVX
            ZSX             21     ZDRVSX
            ZGG             26     ZCHKGG (routines)
            ZGS             26     ZDRGES
            ZGX              5     ZDRGSX
            ZGV             26     ZDRGEV
            ZXV              2     ZDRGVX
            ZSG             21     ZDRVSG
            ZHB             15     ZCHKHB
            ZBB             15     ZCHKBB
            ZEC              -     ZCHKEC
            ZBL              -     ZCHKBL
            ZBK              -     ZCHKBK
            ZGL              -     ZCHKGL
            ZGK              -     ZCHKGK
            GLM              8     ZCKGLM
            GQR              8     ZCKGQR
            GSV              8     ZCKGSV
            CSD              3     ZCKCSD
            LSE              8     ZCKLSE

           -----------------------------------------------------------------------

            NEP input file:

            line 2:  NN, INTEGER
                     Number of values of N.

            line 3:  NVAL, INTEGER array, dimension (NN)
                     The values for the matrix dimension N.

            line 4:  NPARMS, INTEGER
                     Number of values of the parameters NB, NBMIN, NX, NS, and
                     MAXB.

            line 5:  NBVAL, INTEGER array, dimension (NPARMS)
                     The values for the blocksize NB.

            line 6:  NBMIN, INTEGER array, dimension (NPARMS)
                     The values for the minimum blocksize NBMIN.

            line 7:  NXVAL, INTEGER array, dimension (NPARMS)
                     The values for the crossover point NX.

            line 8:  INMIN, INTEGER array, dimension (NPARMS)
                     LAHQR vs TTQRE crossover point, >= 11

            line 9:  INWIN, INTEGER array, dimension (NPARMS)
                     recommended deflation window size

            line 10: INIBL, INTEGER array, dimension (NPARMS)
                     nibble crossover point

            line 11:  ISHFTS, INTEGER array, dimension (NPARMS)
                     number of simultaneous shifts)

            line 12:  IACC22, INTEGER array, dimension (NPARMS)
                     select structured matrix multiply: 0, 1 or 2)

            line 13: THRESH
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.  To have all of the test
                     ratios printed, use THRESH = 0.0 .

            line 14: NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 14 was 2:

            line 15: INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 15-EOF:  The remaining lines occur in sets of 1 or 2 and allow
                     the user to specify the matrix types.  Each line contains
                     a 3-character path name in columns 1-3, and the number
                     of matrix types must be the first nonblank item in columns
                     4-80.  If the number of matrix types is at least 1 but is
                     less than the maximum number of possible types, a second
                     line will be read to get the numbers of the matrix types to
                     be used.  For example,
            NEP 21
                     requests all of the matrix types for the nonsymmetric
                     eigenvalue problem, while
            NEP  4
            9 10 11 12
                     requests only matrices of type 9, 10, 11, and 12.

                     The valid 3-character path names are 'NEP' or 'ZHS' for the
                     nonsymmetric eigenvalue routines.

           -----------------------------------------------------------------------

            SEP or ZSG input file:

            line 2:  NN, INTEGER
                     Number of values of N.

            line 3:  NVAL, INTEGER array, dimension (NN)
                     The values for the matrix dimension N.

            line 4:  NPARMS, INTEGER
                     Number of values of the parameters NB, NBMIN, and NX.

            line 5:  NBVAL, INTEGER array, dimension (NPARMS)
                     The values for the blocksize NB.

            line 6:  NBMIN, INTEGER array, dimension (NPARMS)
                     The values for the minimum blocksize NBMIN.

            line 7:  NXVAL, INTEGER array, dimension (NPARMS)
                     The values for the crossover point NX.

            line 8:  THRESH
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 9:  TSTCHK, LOGICAL
                     Flag indicating whether or not to test the LAPACK routines.

            line 10: TSTDRV, LOGICAL
                     Flag indicating whether or not to test the driver routines.

            line 11: TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 12: NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 12 was 2:

            line 13: INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 13-EOF:  Lines specifying matrix types, as for NEP.
                     The valid 3-character path names are 'SEP' or 'ZST' for the
                     Hermitian eigenvalue routines and driver routines, and
                     'ZSG' for the routines for the Hermitian generalized
                     eigenvalue problem.

           -----------------------------------------------------------------------

            SVD input file:

            line 2:  NN, INTEGER
                     Number of values of M and N.

            line 3:  MVAL, INTEGER array, dimension (NN)
                     The values for the matrix row dimension M.

            line 4:  NVAL, INTEGER array, dimension (NN)
                     The values for the matrix column dimension N.

            line 5:  NPARMS, INTEGER
                     Number of values of the parameter NB, NBMIN, NX, and NRHS.

            line 6:  NBVAL, INTEGER array, dimension (NPARMS)
                     The values for the blocksize NB.

            line 7:  NBMIN, INTEGER array, dimension (NPARMS)
                     The values for the minimum blocksize NBMIN.

            line 8:  NXVAL, INTEGER array, dimension (NPARMS)
                     The values for the crossover point NX.

            line 9:  NSVAL, INTEGER array, dimension (NPARMS)
                     The values for the number of right hand sides NRHS.

            line 10: THRESH
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 11: TSTCHK, LOGICAL
                     Flag indicating whether or not to test the LAPACK routines.

            line 12: TSTDRV, LOGICAL
                     Flag indicating whether or not to test the driver routines.

            line 13: TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 14: NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 14 was 2:

            line 15: INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 15-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path names are 'SVD' or 'ZBD' for both the
                     SVD routines and the SVD driver routines.

           -----------------------------------------------------------------------

            ZEV and ZES data files:

            line 1:  'ZEV' or 'ZES' in columns 1 to 3.

            line 2:  NSIZES, INTEGER
                     Number of sizes of matrices to use. Should be at least 0
                     and at most 20. If NSIZES = 0, no testing is done
                     (although the remaining  3 lines are still read).

            line 3:  NN, INTEGER array, dimension(NSIZES)
                     Dimensions of matrices to be tested.

            line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
                     These integer parameters determine how blocking is done
                     (see ILAENV for details)
                     NB     : block size
                     NBMIN  : minimum block size
                     NX     : minimum dimension for blocking
                     NS     : number of shifts in xHSEQR
                     NBCOL  : minimum column dimension for blocking

            line 5:  THRESH, REAL
                     The test threshold against which computed residuals are
                     compared. Should generally be in the range from 10. to 20.
                     If it is 0., all test case data will be printed.

            line 6:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 6 was 2:

            line 7:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 8 and following:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'ZEV' to test CGEEV, or
                     'ZES' to test CGEES.

           -----------------------------------------------------------------------

            The ZVX data has two parts. The first part is identical to ZEV,
            and the second part consists of test matrices with precomputed
            solutions.

            line 1:  'ZVX' in columns 1-3.

            line 2:  NSIZES, INTEGER
                     If NSIZES = 0, no testing of randomly generated examples
                     is done, but any precomputed examples are tested.

            line 3:  NN, INTEGER array, dimension(NSIZES)

            line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs

            line 5:  THRESH, REAL

            line 6:  NEWSD, INTEGER

            If line 6 was 2:

            line 7:  INTEGER array, dimension (4)

            lines 8 and following: The first line contains 'ZVX' in columns 1-3
                     followed by the number of matrix types, possibly with
                     a second line to specify certain matrix types.
                     If the number of matrix types = 0, no testing of randomly
                     generated examples is done, but any precomputed examples
                     are tested.

            remaining lines : Each matrix is stored on 1+N+N**2 lines, where N is
                     its dimension. The first line contains the dimension N and
                     ISRT (two integers). ISRT indicates whether the last N lines
                     are sorted by increasing real part of the eigenvalue
                     (ISRT=0) or by increasing imaginary part (ISRT=1). The next
                     N**2 lines contain the matrix rowwise, one entry per line.
                     The last N lines correspond to each eigenvalue. Each of
                     these last N lines contains 4 real values: the real part of
                     the eigenvalues, the imaginary part of the eigenvalue, the
                     reciprocal condition number of the eigenvalues, and the
                     reciprocal condition number of the vector eigenvector. The
                     end of data is indicated by dimension N=0. Even if no data
                     is to be tested, there must be at least one line containing
                     N=0.

           -----------------------------------------------------------------------

            The ZSX data is like ZVX. The first part is identical to ZEV, and the
            second part consists of test matrices with precomputed solutions.

            line 1:  'ZSX' in columns 1-3.

            line 2:  NSIZES, INTEGER
                     If NSIZES = 0, no testing of randomly generated examples
                     is done, but any precomputed examples are tested.

            line 3:  NN, INTEGER array, dimension(NSIZES)

            line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs

            line 5:  THRESH, REAL

            line 6:  NEWSD, INTEGER

            If line 6 was 2:

            line 7:  INTEGER array, dimension (4)

            lines 8 and following: The first line contains 'ZSX' in columns 1-3
                     followed by the number of matrix types, possibly with
                     a second line to specify certain matrix types.
                     If the number of matrix types = 0, no testing of randomly
                     generated examples is done, but any precomputed examples
                     are tested.

            remaining lines : Each matrix is stored on 3+N**2 lines, where N is
                     its dimension. The first line contains the dimension N, the
                     dimension M of an invariant subspace, and ISRT. The second
                     line contains M integers, identifying the eigenvalues in the
                     invariant subspace (by their position in a list of
                     eigenvalues ordered by increasing real part (if ISRT=0) or
                     by increasing imaginary part (if ISRT=1)). The next N**2
                     lines contain the matrix rowwise. The last line contains the
                     reciprocal condition number for the average of the selected
                     eigenvalues, and the reciprocal condition number for the
                     corresponding right invariant subspace. The end of data in
                     indicated by a line containing N=0, M=0, and ISRT = 0.  Even
                     if no data is to be tested, there must be at least one line
                     containing N=0, M=0 and ISRT=0.

           -----------------------------------------------------------------------

            ZGG input file:

            line 2:  NN, INTEGER
                     Number of values of N.

            line 3:  NVAL, INTEGER array, dimension (NN)
                     The values for the matrix dimension N.

            line 4:  NPARMS, INTEGER
                     Number of values of the parameters NB, NBMIN, NBCOL, NS, and
                     MAXB.

            line 5:  NBVAL, INTEGER array, dimension (NPARMS)
                     The values for the blocksize NB.

            line 6:  NBMIN, INTEGER array, dimension (NPARMS)
                     The values for NBMIN, the minimum row dimension for blocks.

            line 7:  NSVAL, INTEGER array, dimension (NPARMS)
                     The values for the number of shifts.

            line 8:  MXBVAL, INTEGER array, dimension (NPARMS)
                     The values for MAXB, used in determining minimum blocksize.

            line 9:  IACC22, INTEGER array, dimension (NPARMS)
                     select structured matrix multiply: 1 or 2)

            line 10: NBCOL, INTEGER array, dimension (NPARMS)
                     The values for NBCOL, the minimum column dimension for
                     blocks.

            line 11: THRESH
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 12: TSTCHK, LOGICAL
                     Flag indicating whether or not to test the LAPACK routines.

            line 13: TSTDRV, LOGICAL
                     Flag indicating whether or not to test the driver routines.

            line 14: TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 15: NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 15 was 2:

            line 16: INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 17-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'ZGG' for the generalized
                     eigenvalue problem routines and driver routines.

           -----------------------------------------------------------------------

            ZGS and ZGV input files:

            line 1:  'ZGS' or 'ZGV' in columns 1 to 3.

            line 2:  NN, INTEGER
                     Number of values of N.

            line 3:  NVAL, INTEGER array, dimension(NN)
                     Dimensions of matrices to be tested.

            line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
                     These integer parameters determine how blocking is done
                     (see ILAENV for details)
                     NB     : block size
                     NBMIN  : minimum block size
                     NX     : minimum dimension for blocking
                     NS     : number of shifts in xHGEQR
                     NBCOL  : minimum column dimension for blocking

            line 5:  THRESH, REAL
                     The test threshold against which computed residuals are
                     compared. Should generally be in the range from 10. to 20.
                     If it is 0., all test case data will be printed.

            line 6:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits.

            line 7:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 17 was 2:

            line 7:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 7-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'ZGS' for the generalized
                     eigenvalue problem routines and driver routines.

           -----------------------------------------------------------------------

            ZGX input file:
            line 1:  'ZGX' in columns 1 to 3.

            line 2:  N, INTEGER
                     Value of N.

            line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
                     These integer parameters determine how blocking is done
                     (see ILAENV for details)
                     NB     : block size
                     NBMIN  : minimum block size
                     NX     : minimum dimension for blocking
                     NS     : number of shifts in xHGEQR
                     NBCOL  : minimum column dimension for blocking

            line 4:  THRESH, REAL
                     The test threshold against which computed residuals are
                     compared. Should generally be in the range from 10. to 20.
                     Information will be printed about each test for which the
                     test ratio is greater than or equal to the threshold.

            line 5:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 6:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 6 was 2:

            line 7: INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            If line 2 was 0:

            line 7-EOF: Precomputed examples are tested.

            remaining lines : Each example is stored on 3+2*N*N lines, where N is
                     its dimension. The first line contains the dimension (a
                     single integer).  The next line contains an integer k such
                     that only the last k eigenvalues will be selected and appear
                     in the leading diagonal blocks of $A$ and $B$. The next N*N
                     lines contain the matrix A, one element per line. The next N*N
                     lines contain the matrix B. The last line contains the
                     reciprocal of the eigenvalue cluster condition number and the
                     reciprocal of the deflating subspace (associated with the
                     selected eigencluster) condition number.  The end of data is
                     indicated by dimension N=0.  Even if no data is to be tested,
                     there must be at least one line containing N=0.

           -----------------------------------------------------------------------

            ZXV input files:
            line 1:  'ZXV' in columns 1 to 3.

            line 2:  N, INTEGER
                     Value of N.

            line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs
                     These integer parameters determine how blocking is done
                     (see ILAENV for details)
                     NB     : block size
                     NBMIN  : minimum block size
                     NX     : minimum dimension for blocking
                     NS     : number of shifts in xHGEQR
                     NBCOL  : minimum column dimension for blocking

            line 4:  THRESH, REAL
                     The test threshold against which computed residuals are
                     compared. Should generally be in the range from 10. to 20.
                     Information will be printed about each test for which the
                     test ratio is greater than or equal to the threshold.

            line 5:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 6:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 6 was 2:

            line 7: INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            If line 2 was 0:

            line 7-EOF: Precomputed examples are tested.

            remaining lines : Each example is stored on 3+2*N*N lines, where N is
                     its dimension. The first line contains the dimension (a
                     single integer). The next N*N lines contain the matrix A, one
                     element per line. The next N*N lines contain the matrix B.
                     The next line contains the reciprocals of the eigenvalue
                     condition numbers.  The last line contains the reciprocals of
                     the eigenvector condition numbers.  The end of data is
                     indicated by dimension N=0.  Even if no data is to be tested,
                     there must be at least one line containing N=0.

           -----------------------------------------------------------------------

            ZHB input file:

            line 2:  NN, INTEGER
                     Number of values of N.

            line 3:  NVAL, INTEGER array, dimension (NN)
                     The values for the matrix dimension N.

            line 4:  NK, INTEGER
                     Number of values of K.

            line 5:  KVAL, INTEGER array, dimension (NK)
                     The values for the matrix dimension K.

            line 6:  THRESH
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 7:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 7 was 2:

            line 8:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 8-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'ZHB'.

           -----------------------------------------------------------------------

            ZBB input file:

            line 2:  NN, INTEGER
                     Number of values of M and N.

            line 3:  MVAL, INTEGER array, dimension (NN)
                     The values for the matrix row dimension M.

            line 4:  NVAL, INTEGER array, dimension (NN)
                     The values for the matrix column dimension N.

            line 4:  NK, INTEGER
                     Number of values of K.

            line 5:  KVAL, INTEGER array, dimension (NK)
                     The values for the matrix bandwidth K.

            line 6:  NPARMS, INTEGER
                     Number of values of the parameter NRHS

            line 7:  NSVAL, INTEGER array, dimension (NPARMS)
                     The values for the number of right hand sides NRHS.

            line 8:  THRESH
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 9:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 9 was 2:

            line 10: INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 10-EOF:  Lines specifying matrix types, as for SVD.
                     The 3-character path name is 'ZBB'.

           -----------------------------------------------------------------------

            ZEC input file:

            line  2: THRESH, REAL
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            lines  3-EOF:

            Input for testing the eigencondition routines consists of a set of
            specially constructed test cases and their solutions.  The data
            format is not intended to be modified by the user.

           -----------------------------------------------------------------------

            ZBL and ZBK input files:

            line 1:  'ZBL' in columns 1-3 to test CGEBAL, or 'ZBK' in
                     columns 1-3 to test CGEBAK.

            The remaining lines consist of specially constructed test cases.

           -----------------------------------------------------------------------

            ZGL and ZGK input files:

            line 1:  'ZGL' in columns 1-3 to test ZGGBAL, or 'ZGK' in
                     columns 1-3 to test ZGGBAK.

            The remaining lines consist of specially constructed test cases.

           -----------------------------------------------------------------------

            GLM data file:

            line 1:  'GLM' in columns 1 to 3.

            line 2:  NN, INTEGER
                     Number of values of M, P, and N.

            line 3:  MVAL, INTEGER array, dimension(NN)
                     Values of M (row dimension).

            line 4:  PVAL, INTEGER array, dimension(NN)
                     Values of P (row dimension).

            line 5:  NVAL, INTEGER array, dimension(NN)
                     Values of N (column dimension), note M <= N <= M+P.

            line 6:  THRESH, REAL
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 7:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 8:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 8 was 2:

            line 9:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 9-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'GLM' for the generalized
                     linear regression model routines.

           -----------------------------------------------------------------------

            GQR data file:

            line 1:  'GQR' in columns 1 to 3.

            line 2:  NN, INTEGER
                     Number of values of M, P, and N.

            line 3:  MVAL, INTEGER array, dimension(NN)
                     Values of M.

            line 4:  PVAL, INTEGER array, dimension(NN)
                     Values of P.

            line 5:  NVAL, INTEGER array, dimension(NN)
                     Values of N.

            line 6:  THRESH, REAL
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 7:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 8:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 8 was 2:

            line 9:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 9-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'GQR' for the generalized
                     QR and RQ routines.

           -----------------------------------------------------------------------

            GSV data file:

            line 1:  'GSV' in columns 1 to 3.

            line 2:  NN, INTEGER
                     Number of values of M, P, and N.

            line 3:  MVAL, INTEGER array, dimension(NN)
                     Values of M (row dimension).

            line 4:  PVAL, INTEGER array, dimension(NN)
                     Values of P (row dimension).

            line 5:  NVAL, INTEGER array, dimension(NN)
                     Values of N (column dimension).

            line 6:  THRESH, REAL
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 7:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 8:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 8 was 2:

            line 9:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 9-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'GSV' for the generalized
                     SVD routines.

           -----------------------------------------------------------------------

            CSD data file:

            line 1:  'CSD' in columns 1 to 3.

            line 2:  NM, INTEGER
                     Number of values of M, P, and N.

            line 3:  MVAL, INTEGER array, dimension(NM)
                     Values of M (row and column dimension of orthogonal matrix).

            line 4:  PVAL, INTEGER array, dimension(NM)
                     Values of P (row dimension of top-left block).

            line 5:  NVAL, INTEGER array, dimension(NM)
                     Values of N (column dimension of top-left block).

            line 6:  THRESH, REAL
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 7:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 8:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 8 was 2:

            line 9:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 9-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'CSD' for the CSD routine.

           -----------------------------------------------------------------------

            LSE data file:

            line 1:  'LSE' in columns 1 to 3.

            line 2:  NN, INTEGER
                     Number of values of M, P, and N.

            line 3:  MVAL, INTEGER array, dimension(NN)
                     Values of M.

            line 4:  PVAL, INTEGER array, dimension(NN)
                     Values of P.

            line 5:  NVAL, INTEGER array, dimension(NN)
                     Values of N, note P <= N <= P+M.

            line 6:  THRESH, REAL
                     Threshold value for the test ratios.  Information will be
                     printed about each test for which the test ratio is greater
                     than or equal to the threshold.

            line 7:  TSTERR, LOGICAL
                     Flag indicating whether or not to test the error exits for
                     the LAPACK routines and driver routines.

            line 8:  NEWSD, INTEGER
                     A code indicating how to set the random number seed.
                     = 0:  Set the seed to a default value before each run
                     = 1:  Initialize the seed to a default value only before the
                           first run
                     = 2:  Like 1, but use the seed values on the next line

            If line 8 was 2:

            line 9:  INTEGER array, dimension (4)
                     Four integer values for the random number seed.

            lines 9-EOF:  Lines specifying matrix types, as for NEP.
                     The 3-character path name is 'GSV' for the generalized
                     SVD routines.

           -----------------------------------------------------------------------

            NMAX is currently set to 132 and must be at least 12 for some of the
            precomputed examples, and LWORK = NMAX*(5*NMAX+20) in the parameter
            statements below.  For SVD, we assume NRHS may be as big as N.  The
            parameter NEED is set to 14 to allow for 14 N-by-N matrices for ZGG.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zchkgg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, logical
       TSTDIF, double precision THRSHN, integer NOUNIT, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( lda, * ) B, complex*16, dimension( lda, * ) H,
       complex*16, dimension( lda, * ) T, complex*16, dimension( lda, * ) S1, complex*16,
       dimension( lda, * ) S2, complex*16, dimension( lda, * ) P1, complex*16, dimension( lda, *
       ) P2, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( ldu, * ) V,
       complex*16, dimension( ldu, * ) Q, complex*16, dimension( ldu, * ) Z, complex*16,
       dimension( * ) ALPHA1, complex*16, dimension( * ) BETA1, complex*16, dimension( * )
       ALPHA3, complex*16, dimension( * ) BETA3, complex*16, dimension( ldu, * ) EVECTL,
       complex*16, dimension( ldu, * ) EVECTR, complex*16, dimension( * ) WORK, integer LWORK,
       double precision, dimension( * ) RWORK, logical, dimension( * ) LLWORK, double precision,
       dimension( 15 ) RESULT, integer INFO)
       ZCHKGG

       Purpose:

            ZCHKGG  checks the nonsymmetric generalized eigenvalue problem
            routines.
                                           H          H        H
            ZGGHRD factors A and B as U H V  and U T V , where   means conjugate
            transpose, H is hessenberg, T is triangular and U and V are unitary.

                                            H          H
            ZHGEQZ factors H and T as  Q S Z  and Q P Z , where P and S are upper
            triangular and Q and Z are unitary.  It also computes the generalized
            eigenvalues (alpha(1),beta(1)),...,(alpha(n),beta(n)), where
            alpha(j)=S(j,j) and beta(j)=P(j,j) -- thus, w(j) = alpha(j)/beta(j)
            is a root of the generalized eigenvalue problem

                det( A - w(j) B ) = 0

            and m(j) = beta(j)/alpha(j) is a root of the essentially equivalent
            problem

                det( m(j) A - B ) = 0

            ZTGEVC computes the matrix L of left eigenvectors and the matrix R
            of right eigenvectors for the matrix pair ( S, P ).  In the
            description below,  l and r are left and right eigenvectors
            corresponding to the generalized eigenvalues (alpha,beta).

            When ZCHKGG is called, a number of matrix "sizes" ("n's") and a
            number of matrix "types" are specified.  For each size ("n")
            and each type of matrix, one matrix will be generated and used
            to test the nonsymmetric eigenroutines.  For each matrix, 13
            tests will be performed.  The first twelve "test ratios" should be
            small -- O(1).  They will be compared with the threshold THRESH:

                             H
            (1)   | A - U H V  | / ( |A| n ulp )

                             H
            (2)   | B - U T V  | / ( |B| n ulp )

                          H
            (3)   | I - UU  | / ( n ulp )

                          H
            (4)   | I - VV  | / ( n ulp )

                             H
            (5)   | H - Q S Z  | / ( |H| n ulp )

                             H
            (6)   | T - Q P Z  | / ( |T| n ulp )

                          H
            (7)   | I - QQ  | / ( n ulp )

                          H
            (8)   | I - ZZ  | / ( n ulp )

            (9)   max over all left eigenvalue/-vector pairs (beta/alpha,l) of
                                      H
                  | (beta A - alpha B) l | / ( ulp max( |beta A|, |alpha B| ) )

            (10)  max over all left eigenvalue/-vector pairs (beta/alpha,l') of
                                      H
                  | (beta H - alpha T) l' | / ( ulp max( |beta H|, |alpha T| ) )

                  where the eigenvectors l' are the result of passing Q to
                  DTGEVC and back transforming (JOB='B').

            (11)  max over all right eigenvalue/-vector pairs (beta/alpha,r) of

                  | (beta A - alpha B) r | / ( ulp max( |beta A|, |alpha B| ) )

            (12)  max over all right eigenvalue/-vector pairs (beta/alpha,r') of

                  | (beta H - alpha T) r' | / ( ulp max( |beta H|, |alpha T| ) )

                  where the eigenvectors r' are the result of passing Z to
                  DTGEVC and back transforming (JOB='B').

            The last three test ratios will usually be small, but there is no
            mathematical requirement that they be so.  They are therefore
            compared with THRESH only if TSTDIF is .TRUE.

            (13)  | S(Q,Z computed) - S(Q,Z not computed) | / ( |S| ulp )

            (14)  | P(Q,Z computed) - P(Q,Z not computed) | / ( |P| ulp )

            (15)  max( |alpha(Q,Z computed) - alpha(Q,Z not computed)|/|S| ,
                       |beta(Q,Z computed) - beta(Q,Z not computed)|/|P| ) / ulp

            In addition, the normalization of L and R are checked, and compared
            with the threshold THRSHN.

            Test Matrices
            ---- --------

            The sizes of the test matrices are specified by an array
            NN(1:NSIZES); the value of each element 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)  ( 0, 0 )         (a pair of zero matrices)

            (2)  ( I, 0 )         (an identity and a zero matrix)

            (3)  ( 0, I )         (an identity and a zero matrix)

            (4)  ( I, I )         (a pair of identity matrices)

                    t   t
            (5)  ( J , J  )       (a pair of transposed Jordan blocks)

                                                t                ( I   0  )
            (6)  ( X, Y )         where  X = ( J   0  )  and Y = (      t )
                                             ( 0   I  )          ( 0   J  )
                                  and I is a k x k identity and J a (k+1)x(k+1)
                                  Jordan block; k=(N-1)/2

            (7)  ( D, I )         where D is P*D1, P is a random unitary diagonal
                                  matrix (i.e., with random magnitude 1 entries
                                  on the diagonal), and D1=diag( 0, 1,..., N-1 )
                                  (i.e., a diagonal matrix with D1(1,1)=0,
                                  D1(2,2)=1, ..., D1(N,N)=N-1.)
            (8)  ( I, D )

            (9)  ( big*D, small*I ) where "big" is near overflow and small=1/big

            (10) ( small*D, big*I )

            (11) ( big*I, small*D )

            (12) ( small*I, big*D )

            (13) ( big*D, big*I )

            (14) ( small*D, small*I )

            (15) ( D1, D2 )        where D1=P*diag( 0, 0, 1, ..., N-3, 0 ) and
                                   D2=Q*diag( 0, N-3, N-4,..., 1, 0, 0 ), and
                                   P and Q are random unitary diagonal matrices.
                      t   t
            (16) U ( J , J ) V     where U and V are random unitary matrices.

            (17) U ( T1, T2 ) V    where T1 and T2 are upper triangular matrices
                                   with random O(1) entries above the diagonal
                                   and diagonal entries diag(T1) =
                                   P*( 0, 0, 1, ..., N-3, 0 ) and diag(T2) =
                                   Q*( 0, N-3, N-4,..., 1, 0, 0 )

            (18) U ( T1, T2 ) V    diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1,..., 1, 0 )
                                   s = machine precision.

            (19) U ( T1, T2 ) V    diag(T1)=( 0,0,1,1, 1-d, ..., 1-(N-5)*d=s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )

                                                                   N-5
            (20) U ( T1, T2 ) V    diag(T1)=( 0, 0, 1, 1, a, ..., a   =s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )

            (21) U ( T1, T2 ) V    diag(T1)=( 0, 0, 1, r1, r2, ..., r(N-4), 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
                                   where r1,..., r(N-4) are random.

            (22) U ( big*T1, small*T2 ) V   diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
                                            diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (23) U ( small*T1, big*T2 ) V   diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
                                            diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (24) U ( small*T1, small*T2 ) V diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
                                            diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (25) U ( big*T1, big*T2 ) V     diag(T1) = P*( 0, 0, 1, ..., N-3, 0 )
                                            diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (26) U ( T1, T2 ) V     where T1 and T2 are random upper-triangular
                                    matrices.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZCHKGG does nothing.  It must be at least zero.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZCHKGG
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZCHKGG to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           TSTDIF

                     TSTDIF is LOGICAL
                     Specifies whether test ratios 13-15 will be computed and
                     compared with THRESH.
                     = .FALSE.: Only test ratios 1-12 will be computed and tested.
                                Ratios 13-15 will be set to zero.
                     = .TRUE.:  All the test ratios 1-15 will be computed and
                                tested.

           THRSHN

                     THRSHN is DOUBLE PRECISION
                     Threshold for reporting eigenvector normalization error.
                     If the normalization of any eigenvector differs from 1 by
                     more than THRSHN*ulp, then a special error message will be
                     printed.  (This is handled separately from the other tests,
                     since only a compiler or programming error should cause an
                     error message, at least if THRSHN is at least 5--10.)

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension (LDA, max(NN))
                     Used to hold the original A matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, B, H, T, S1, P1, S2, and P2.
                     It must be at least 1 and at least max( NN ).

           B

                     B is COMPLEX*16 array, dimension (LDA, max(NN))
                     Used to hold the original B matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           H

                     H is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper Hessenberg matrix computed from A by ZGGHRD.

           T

                     T is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper triangular matrix computed from B by ZGGHRD.

           S1

                     S1 is COMPLEX*16 array, dimension (LDA, max(NN))
                     The Schur (upper triangular) matrix computed from H by ZHGEQZ
                     when Q and Z are also computed.

           S2

                     S2 is COMPLEX*16 array, dimension (LDA, max(NN))
                     The Schur (upper triangular) matrix computed from H by ZHGEQZ
                     when Q and Z are not computed.

           P1

                     P1 is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper triangular matrix computed from T by ZHGEQZ
                     when Q and Z are also computed.

           P2

                     P2 is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper triangular matrix computed from T by ZHGEQZ
                     when Q and Z are not computed.

           U

                     U is COMPLEX*16 array, dimension (LDU, max(NN))
                     The (left) unitary matrix computed by ZGGHRD.

           LDU

                     LDU is INTEGER
                     The leading dimension of U, V, Q, Z, EVECTL, and EVEZTR.  It
                     must be at least 1 and at least max( NN ).

           V

                     V is COMPLEX*16 array, dimension (LDU, max(NN))
                     The (right) unitary matrix computed by ZGGHRD.

           Q

                     Q is COMPLEX*16 array, dimension (LDU, max(NN))
                     The (left) unitary matrix computed by ZHGEQZ.

           Z

                     Z is COMPLEX*16 array, dimension (LDU, max(NN))
                     The (left) unitary matrix computed by ZHGEQZ.

           ALPHA1

                     ALPHA1 is COMPLEX*16 array, dimension (max(NN))

           BETA1

                     BETA1 is COMPLEX*16 array, dimension (max(NN))
                     The generalized eigenvalues of (A,B) computed by ZHGEQZ
                     when Q, Z, and the full Schur matrices are computed.

           ALPHA3

                     ALPHA3 is COMPLEX*16 array, dimension (max(NN))

           BETA3

                     BETA3 is COMPLEX*16 array, dimension (max(NN))
                     The generalized eigenvalues of (A,B) computed by ZHGEQZ
                     when neither Q, Z, nor the Schur matrices are computed.

           EVECTL

                     EVECTL is COMPLEX*16 array, dimension (LDU, max(NN))
                     The (lower triangular) left eigenvector matrix for the
                     matrices in S1 and P1.

           EVECTR

                     EVECTR is COMPLEX*16 array, dimension (LDU, max(NN))
                     The (upper triangular) right eigenvector matrix for the
                     matrices in S1 and P1.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     max( 4*N, 2 * N**2, 1 ), for all N=NN(j).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*max(NN))

           LLWORK

                     LLWORK is LOGICAL array, dimension (max(NN))

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (15)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit.
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  A routine returned an error code.  INFO is the
                           absolute value of the INFO value returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkgk (integer NIN, integer NOUT)
       ZCHKGK

       Purpose:

            ZCHKGK tests ZGGBAK, a routine for backward balancing  of
            a matrix pair (A, B).

       Parameters:
           NIN

                     NIN is INTEGER
                     The logical unit number for input.  NIN > 0.

           NOUT

                     NOUT is INTEGER
                     The logical unit number for output.  NOUT > 0.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkgl (integer NIN, integer NOUT)
       ZCHKGL

       Purpose:

            ZCHKGL tests ZGGBAL, a routine for balancing a matrix pair (A, B).

       Parameters:
           NIN

                     NIN is INTEGER
                     The logical unit number for input.  NIN > 0.

           NOUT

                     NOUT is INTEGER
                     The logical unit number for output.  NOUT > 0.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkhb (integer NSIZES, integer, dimension( * ) NN, integer NWDTHS, integer,
       dimension( * ) KK, integer NTYPES, logical, dimension( * ) DOTYPE, integer, dimension( 4 )
       ISEED, double precision THRESH, integer NOUNIT, complex*16, dimension( lda, * ) A, integer
       LDA, double precision, dimension( * ) SD, double precision, dimension( * ) SE, complex*16,
       dimension( ldu, * ) U, integer LDU, complex*16, dimension( * ) WORK, integer LWORK, double
       precision, dimension( * ) RWORK, double precision, dimension( * ) RESULT, integer INFO)
       ZCHKHB

       Purpose:

            ZCHKHB tests the reduction of a Hermitian band matrix to tridiagonal
            from, used with the Hermitian eigenvalue problem.

            ZHBTRD factors a Hermitian band matrix A as  U S U* , where * means
            conjugate transpose, S is symmetric tridiagonal, and U is unitary.
            ZHBTRD can use either just the lower or just the upper triangle
            of A; ZCHKHB checks both cases.

            When ZCHKHB is called, a number of matrix "sizes" ("n's"), a number
            of bandwidths ("k's"), and a number of matrix "types" are
            specified.  For each size ("n"), each bandwidth ("k") less than or
            equal to "n", and each type of matrix, one matrix will be generated
            and used to test the hermitian banded reduction routine.  For each
            matrix, a number of tests will be performed:

            (1)     | A - V S V* | / ( |A| n ulp )  computed by ZHBTRD with
                                                    UPLO='U'

            (2)     | I - UU* | / ( n ulp )

            (3)     | A - V S V* | / ( |A| n ulp )  computed by ZHBTRD with
                                                    UPLO='L'

            (4)     | I - UU* | / ( n ulp )

            The "sizes" are specified by an array NN(1:NSIZES); the value of
            each element 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 diagonal matrix with evenly spaced entries
                 1, ..., ULP  and random signs.
                 (ULP = (first number larger than 1) - 1 )
            (4)  A diagonal matrix with geometrically spaced entries
                 1, ..., ULP  and random signs.
            (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                 and random signs.

            (6)  Same as (4), but multiplied by SQRT( overflow threshold )
            (7)  Same as (4), but multiplied by SQRT( underflow threshold )

            (8)  A matrix of the form  U* D U, where U is unitary and
                 D has evenly spaced entries 1, ..., ULP with random signs
                 on the diagonal.

            (9)  A matrix of the form  U* D U, where U is unitary and
                 D has geometrically spaced entries 1, ..., ULP with random
                 signs on the diagonal.

            (10) A matrix of the form  U* D U, where U is unitary and
                 D has "clustered" entries 1, ULP,..., ULP with random
                 signs on the diagonal.

            (11) Same as (8), but multiplied by SQRT( overflow threshold )
            (12) Same as (8), but multiplied by SQRT( underflow threshold )

            (13) Hermitian matrix with random entries chosen from (-1,1).
            (14) Same as (13), but multiplied by SQRT( overflow threshold )
            (15) Same as (13), but multiplied by SQRT( underflow threshold )

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZCHKHB does nothing.  It must be at least zero.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.

           NWDTHS

                     NWDTHS is INTEGER
                     The number of bandwidths to use.  If it is zero,
                     ZCHKHB does nothing.  It must be at least zero.

           KK

                     KK is INTEGER array, dimension (NWDTHS)
                     An array containing the bandwidths to be used for the band
                     matrices.  The values must be at least zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZCHKHB
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZCHKHB to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension
                                       (LDA, max(NN))
                     Used to hold the matrix whose eigenvalues are to be
                     computed.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at least 2 (not 1!)
                     and at least max( KK )+1.

           SD

                     SD is DOUBLE PRECISION array, dimension (max(NN))
                     Used to hold the diagonal of the tridiagonal matrix computed
                     by ZHBTRD.

           SE

                     SE is DOUBLE PRECISION array, dimension (max(NN))
                     Used to hold the off-diagonal of the tridiagonal matrix
                     computed by ZHBTRD.

           U

                     U is COMPLEX*16 array, dimension (LDU, max(NN))
                     Used to hold the unitary matrix computed by ZHBTRD.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  It must be at least 1
                     and at least max( NN ).

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     max( LDA+1, max(NN)+1 )*max(NN).

           RWORK

                     RWORK is DOUBLE PRECISION array

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           INFO

                     INFO is INTEGER
                     If 0, then everything ran OK.

           -----------------------------------------------------------------------

                  Some Local Variables and Parameters:
                  ---- ----- --------- --- ----------
                  ZERO, ONE       Real 0 and 1.
                  MAXTYP          The number of types defined.
                  NTEST           The number of tests performed, or which can
                                  be performed so far, for the current matrix.
                  NTESTT          The total number of tests performed so far.
                  NMAX            Largest value in NN.
                  NMATS           The number of matrices generated so far.
                  NERRS           The number of tests which have exceeded THRESH
                                  so far.
                  COND, IMODE     Values to be passed to the matrix generators.
                  ANORM           Norm of A; passed to matrix generators.

                  OVFL, UNFL      Overflow and underflow thresholds.
                  ULP, ULPINV     Finest relative precision and its inverse.
                  RTOVFL, RTUNFL  Square roots of the previous 2 values.
                          The following four arrays decode JTYPE:
                  KTYPE(j)        The general type (1-10) for type "j".
                  KMODE(j)        The MODE value to be passed to the matrix
                                  generator for type "j".
                  KMAGN(j)        The order of magnitude ( O(1),
                                  O(overflow^(1/2) ), O(underflow^(1/2) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkhs (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H,
       complex*16, dimension( lda, * ) T1, complex*16, dimension( lda, * ) T2, complex*16,
       dimension( ldu, * ) U, integer LDU, complex*16, dimension( ldu, * ) Z, complex*16,
       dimension( ldu, * ) UZ, complex*16, dimension( * ) W1, complex*16, dimension( * ) W3,
       complex*16, dimension( ldu, * ) EVECTL, complex*16, dimension( ldu, * ) EVECTR,
       complex*16, dimension( ldu, * ) EVECTY, complex*16, dimension( ldu, * ) EVECTX,
       complex*16, dimension( ldu, * ) UU, complex*16, dimension( * ) TAU, complex*16, dimension(
       * ) WORK, integer NWORK, double precision, dimension( * ) RWORK, integer, dimension( * )
       IWORK, logical, dimension( * ) SELECT, double precision, dimension( 14 ) RESULT, integer
       INFO)
       ZCHKHS

       Purpose:

               ZCHKHS  checks the nonsymmetric eigenvalue problem routines.

                       ZGEHRD factors A as  U H U' , where ' means conjugate
                       transpose, H is hessenberg, and U is unitary.

                       ZUNGHR generates the unitary matrix U.

                       ZUNMHR multiplies a matrix by the unitary matrix U.

                       ZHSEQR factors H as  Z T Z' , where Z is unitary and T
                       is upper triangular.  It also computes the eigenvalues,
                       w(1), ..., w(n); we define a diagonal matrix W whose
                       (diagonal) entries are the eigenvalues.

                       ZTREVC computes the left eigenvector matrix L and the
                       right eigenvector matrix R for the matrix T.  The
                       columns of L are the complex conjugates of the left
                       eigenvectors of T.  The columns of R are the right
                       eigenvectors of T.  L is lower triangular, and R is
                       upper triangular.

                       ZHSEIN computes the left eigenvector matrix Y and the
                       right eigenvector matrix X for the matrix H.  The
                       columns of Y are the complex conjugates of the left
                       eigenvectors of H.  The columns of X are the right
                       eigenvectors of H.  Y is lower triangular, and X is
                       upper triangular.

               When ZCHKHS is called, a number of matrix "sizes" ("n's") and a
               number of matrix "types" are specified.  For each size ("n")
               and each type of matrix, one matrix will be generated and used
               to test the nonsymmetric eigenroutines.  For each matrix, 14
               tests will be performed:

               (1)     | A - U H U**H | / ( |A| n ulp )

               (2)     | I - UU**H | / ( n ulp )

               (3)     | H - Z T Z**H | / ( |H| n ulp )

               (4)     | I - ZZ**H | / ( n ulp )

               (5)     | A - UZ H (UZ)**H | / ( |A| n ulp )

               (6)     | I - UZ (UZ)**H | / ( n ulp )

               (7)     | T(Z computed) - T(Z not computed) | / ( |T| ulp )

               (8)     | W(Z computed) - W(Z not computed) | / ( |W| ulp )

               (9)     | TR - RW | / ( |T| |R| ulp )

               (10)    | L**H T - W**H L | / ( |T| |L| ulp )

               (11)    | HX - XW | / ( |H| |X| ulp )

               (12)    | Y**H H - W**H Y | / ( |H| |Y| ulp )

               (13)    | AX - XW | / ( |A| |X| ulp )

               (14)    | Y**H A - W**H Y | / ( |A| |Y| ulp )

               The "sizes" are specified by an array NN(1:NSIZES); the value of
               each element 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 (transposed) Jordan block, with 1's on the diagonal.

               (4)  A diagonal matrix with evenly spaced entries
                    1, ..., ULP  and random complex angles.
                    (ULP = (first number larger than 1) - 1 )
               (5)  A diagonal matrix with geometrically spaced entries
                    1, ..., ULP  and random complex angles.
               (6)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                    and random complex angles.

               (7)  Same as (4), but multiplied by SQRT( overflow threshold )
               (8)  Same as (4), but multiplied by SQRT( underflow threshold )

               (9)  A matrix of the form  U' T U, where U is unitary and
                    T has evenly spaced entries 1, ..., ULP with random complex
                    angles on the diagonal and random O(1) entries in the upper
                    triangle.

               (10) A matrix of the form  U' T U, where U is unitary and
                    T has geometrically spaced entries 1, ..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (11) A matrix of the form  U' T U, where U is unitary and
                    T has "clustered" entries 1, ULP,..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (12) A matrix of the form  U' T U, where U is unitary and
                    T has complex eigenvalues randomly chosen from
                    ULP < |z| < 1   and random O(1) entries in the upper
                    triangle.

               (13) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (14) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has geometrically spaced entries
                    1, ..., ULP with random complex angles on the diagonal
                    and random O(1) entries in the upper triangle.

               (15) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (16) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has complex eigenvalues randomly chosen
                    from   ULP < |z| < 1   and random O(1) entries in the upper
                    triangle.

               (17) Same as (16), but multiplied by SQRT( overflow threshold )
               (18) Same as (16), but multiplied by SQRT( underflow threshold )

               (19) Nonsymmetric matrix with random entries chosen from |z| < 1
               (20) Same as (19), but multiplied by SQRT( overflow threshold )
               (21) Same as (19), but multiplied by SQRT( underflow threshold )

             NSIZES - INTEGER
                      The number of sizes of matrices to use.  If it is zero,
                      ZCHKHS does nothing.  It must be at least zero.
                      Not modified.

             NN     - INTEGER array, dimension (NSIZES)
                      An array containing the sizes to be used for the matrices.
                      Zero values will be skipped.  The values must be at least
                      zero.
                      Not modified.

             NTYPES - INTEGER
                      The number of elements in DOTYPE.   If it is zero, ZCHKHS
                      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 matrix is in A.  This
                      is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                      DOTYPE(MAXTYP+1) is .TRUE. .
                      Not modified.

             DOTYPE - LOGICAL array, dimension (NTYPES)
                      If DOTYPE(j) is .TRUE., then for each size in NN a
                      matrix of that size and 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.
                      Not modified.

             ISEED  - 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 ZCHKHS to continue the same random number
                      sequence.
                      Modified.

             THRESH - DOUBLE PRECISION
                      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.
                      Not modified.

             NOUNIT - INTEGER
                      The FORTRAN unit number for printing out error messages
                      (e.g., if a routine returns IINFO not equal to 0.)
                      Not modified.

             A      - COMPLEX*16 array, dimension (LDA,max(NN))
                      Used to hold the matrix whose eigenvalues are to be
                      computed.  On exit, A contains the last matrix actually
                      used.
                      Modified.

             LDA    - INTEGER
                      The leading dimension of A, H, T1 and T2.  It must be at
                      least 1 and at least max( NN ).
                      Not modified.

             H      - COMPLEX*16 array, dimension (LDA,max(NN))
                      The upper hessenberg matrix computed by ZGEHRD.  On exit,
                      H contains the Hessenberg form of the matrix in A.
                      Modified.

             T1     - COMPLEX*16 array, dimension (LDA,max(NN))
                      The Schur (="quasi-triangular") matrix computed by ZHSEQR
                      if Z is computed.  On exit, T1 contains the Schur form of
                      the matrix in A.
                      Modified.

             T2     - COMPLEX*16 array, dimension (LDA,max(NN))
                      The Schur matrix computed by ZHSEQR when Z is not computed.
                      This should be identical to T1.
                      Modified.

             LDU    - INTEGER
                      The leading dimension of U, Z, UZ and UU.  It must be at
                      least 1 and at least max( NN ).
                      Not modified.

             U      - COMPLEX*16 array, dimension (LDU,max(NN))
                      The unitary matrix computed by ZGEHRD.
                      Modified.

             Z      - COMPLEX*16 array, dimension (LDU,max(NN))
                      The unitary matrix computed by ZHSEQR.
                      Modified.

             UZ     - COMPLEX*16 array, dimension (LDU,max(NN))
                      The product of U times Z.
                      Modified.

             W1     - COMPLEX*16 array, dimension (max(NN))
                      The eigenvalues of A, as computed by a full Schur
                      decomposition H = Z T Z'.  On exit, W1 contains the
                      eigenvalues of the matrix in A.
                      Modified.

             W3     - COMPLEX*16 array, dimension (max(NN))
                      The eigenvalues of A, as computed by a partial Schur
                      decomposition (Z not computed, T only computed as much
                      as is necessary for determining eigenvalues).  On exit,
                      W3 contains the eigenvalues of the matrix in A, possibly
                      perturbed by ZHSEIN.
                      Modified.

             EVECTL - COMPLEX*16 array, dimension (LDU,max(NN))
                      The conjugate transpose of the (upper triangular) left
                      eigenvector matrix for the matrix in T1.
                      Modified.

             EVEZTR - COMPLEX*16 array, dimension (LDU,max(NN))
                      The (upper triangular) right eigenvector matrix for the
                      matrix in T1.
                      Modified.

             EVECTY - COMPLEX*16 array, dimension (LDU,max(NN))
                      The conjugate transpose of the left eigenvector matrix
                      for the matrix in H.
                      Modified.

             EVECTX - COMPLEX*16 array, dimension (LDU,max(NN))
                      The right eigenvector matrix for the matrix in H.
                      Modified.

             UU     - COMPLEX*16 array, dimension (LDU,max(NN))
                      Details of the unitary matrix computed by ZGEHRD.
                      Modified.

             TAU    - COMPLEX*16 array, dimension (max(NN))
                      Further details of the unitary matrix computed by ZGEHRD.
                      Modified.

             WORK   - COMPLEX*16 array, dimension (NWORK)
                      Workspace.
                      Modified.

             NWORK  - INTEGER
                      The number of entries in WORK.  NWORK >= 4*NN(j)*NN(j) + 2.

             RWORK  - DOUBLE PRECISION array, dimension (max(NN))
                      Workspace.  Could be equivalenced to IWORK, but not SELECT.
                      Modified.

             IWORK  - INTEGER array, dimension (max(NN))
                      Workspace.
                      Modified.

             SELECT - LOGICAL array, dimension (max(NN))
                      Workspace.  Could be equivalenced to IWORK, but not RWORK.
                      Modified.

             RESULT - DOUBLE PRECISION array, dimension (14)
                      The values computed by the fourteen tests described above.
                      The values are currently limited to 1/ulp, to avoid
                      overflow.
                      Modified.

             INFO   - INTEGER
                      If 0, then everything ran OK.
                       -1: NSIZES < 0
                       -2: Some NN(j) < 0
                       -3: NTYPES < 0
                       -6: THRESH < 0
                       -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
                      -14: LDU < 1 or LDU < NMAX.
                      -26: NWORK too small.
                      If  ZLATMR, CLATMS, or CLATME returns an error code, the
                          absolute value of it is returned.
                      If 1, then ZHSEQR could not find all the shifts.
                      If 2, then the EISPACK code (for small blocks) failed.
                      If >2, then 30*N iterations were not enough to find an
                          eigenvalue or to decompose the problem.
                      Modified.

           -----------------------------------------------------------------------

                Some Local Variables and Parameters:
                ---- ----- --------- --- ----------

                ZERO, ONE       Real 0 and 1.
                MAXTYP          The number of types defined.
                MTEST           The number of tests defined: care must be taken
                                that (1) the size of RESULT, (2) the number of
                                tests actually performed, and (3) MTEST agree.
                NTEST           The number of tests performed on this matrix
                                so far.  This should be less than MTEST, and
                                equal to it by the last test.  It will be less
                                if any of the routines being tested indicates
                                that it could not compute the matrices that
                                would be tested.
                NMAX            Largest value in NN.
                NMATS           The number of matrices generated so far.
                NERRS           The number of tests which have exceeded THRESH
                                so far (computed by DLAFTS).
                COND, CONDS,
                IMODE           Values to be passed to the matrix generators.
                ANORM           Norm of A; passed to matrix generators.

                OVFL, UNFL      Overflow and underflow thresholds.
                ULP, ULPINV     Finest relative precision and its inverse.
                RTOVFL, RTUNFL,
                RTULP, RTULPI   Square roots of the previous 4 values.

                        The following four arrays decode JTYPE:
                KTYPE(j)        The general type (1-10) for type "j".
                KMODE(j)        The MODE value to be passed to the matrix
                                generator for type "j".
                KMAGN(j)        The order of magnitude ( O(1),
                                O(overflow^(1/2) ), O(underflow^(1/2) )
                KCONDS(j)       Selects whether CONDS is to be 1 or
                                1/sqrt(ulp).  (0 means irrelevant.)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zchkst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) AP,
       double precision, dimension( * ) SD, double precision, dimension( * ) SE, double
       precision, dimension( * ) D1, double precision, dimension( * ) D2, double precision,
       dimension( * ) D3, double precision, dimension( * ) D4, double precision, dimension( * )
       D5, double precision, dimension( * ) WA1, double precision, dimension( * ) WA2, double
       precision, dimension( * ) WA3, double precision, dimension( * ) WR, complex*16, dimension(
       ldu, * ) U, integer LDU, complex*16, dimension( ldu, * ) V, complex*16, dimension( * ) VP,
       complex*16, dimension( * ) TAU, complex*16, dimension( ldu, * ) Z, complex*16, dimension(
       * ) WORK, integer LWORK, double precision, dimension( * ) RWORK, integer LRWORK, integer,
       dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer
       INFO)
       ZCHKST

       Purpose:

            ZCHKST  checks the Hermitian eigenvalue problem routines.

               ZHETRD factors A as  U S U* , where * means conjugate transpose,
               S is real symmetric tridiagonal, and U is unitary.
               ZHETRD can use either just the lower or just the upper triangle
               of A; ZCHKST checks both cases.
               U is represented as a product of Householder
               transformations, whose vectors are stored in the first
               n-1 columns of V, and whose scale factors are in TAU.

               ZHPTRD does the same as ZHETRD, except that A and V are stored
               in "packed" format.

               ZUNGTR constructs the matrix U from the contents of V and TAU.

               ZUPGTR constructs the matrix U from the contents of VP and TAU.

               ZSTEQR factors S as  Z D1 Z* , where Z is the unitary
               matrix of eigenvectors and D1 is a diagonal matrix with
               the eigenvalues on the diagonal.  D2 is the matrix of
               eigenvalues computed when Z is not computed.

               DSTERF computes D3, the matrix of eigenvalues, by the
               PWK method, which does not yield eigenvectors.

               ZPTEQR factors S as  Z4 D4 Z4* , for a
               Hermitian positive definite tridiagonal matrix.
               D5 is the matrix of eigenvalues computed when Z is not
               computed.

               DSTEBZ computes selected eigenvalues.  WA1, WA2, and
               WA3 will denote eigenvalues computed to high
               absolute accuracy, with different range options.
               WR will denote eigenvalues computed to high relative
               accuracy.

               ZSTEIN computes Y, the eigenvectors of S, given the
               eigenvalues.

               ZSTEDC factors S as Z D1 Z* , where Z is the unitary
               matrix of eigenvectors and D1 is a diagonal matrix with
               the eigenvalues on the diagonal ('I' option). It may also
               update an input unitary matrix, usually the output
               from ZHETRD/ZUNGTR or ZHPTRD/ZUPGTR ('V' option). It may
               also just compute eigenvalues ('N' option).

               ZSTEMR factors S as Z D1 Z* , where Z is the unitary
               matrix of eigenvectors and D1 is a diagonal matrix with
               the eigenvalues on the diagonal ('I' option).  ZSTEMR
               uses the Relatively Robust Representation whenever possible.

            When ZCHKST is called, a number of matrix "sizes" ("n's") and a
            number of matrix "types" are specified.  For each size ("n")
            and each type of matrix, one matrix will be generated and used
            to test the Hermitian eigenroutines.  For each matrix, a number
            of tests will be performed:

            (1)     | A - V S V* | / ( |A| n ulp ) ZHETRD( UPLO='U', ... )

            (2)     | I - UV* | / ( n ulp )        ZUNGTR( UPLO='U', ... )

            (3)     | A - V S V* | / ( |A| n ulp ) ZHETRD( UPLO='L', ... )

            (4)     | I - UV* | / ( n ulp )        ZUNGTR( UPLO='L', ... )

            (5-8)   Same as 1-4, but for ZHPTRD and ZUPGTR.

            (9)     | S - Z D Z* | / ( |S| n ulp ) ZSTEQR('V',...)

            (10)    | I - ZZ* | / ( n ulp )        ZSTEQR('V',...)

            (11)    | D1 - D2 | / ( |D1| ulp )        ZSTEQR('N',...)

            (12)    | D1 - D3 | / ( |D1| ulp )        DSTERF

            (13)    0 if the true eigenvalues (computed by sturm count)
                    of S are within THRESH of
                    those in D1.  2*THRESH if they are not.  (Tested using
                    DSTECH)

            For S positive definite,

            (14)    | S - Z4 D4 Z4* | / ( |S| n ulp ) ZPTEQR('V',...)

            (15)    | I - Z4 Z4* | / ( n ulp )        ZPTEQR('V',...)

            (16)    | D4 - D5 | / ( 100 |D4| ulp )       ZPTEQR('N',...)

            When S is also diagonally dominant by the factor gamma < 1,

            (17)    max | D4(i) - WR(i) | / ( |D4(i)| omega ) ,
                     i
                    omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
                                                         DSTEBZ( 'A', 'E', ...)

            (18)    | WA1 - D3 | / ( |D3| ulp )          DSTEBZ( 'A', 'E', ...)

            (19)    ( max { min | WA2(i)-WA3(j) | } +
                       i     j
                      max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
                       i     j
                                                         DSTEBZ( 'I', 'E', ...)

            (20)    | S - Y WA1 Y* | / ( |S| n ulp )  DSTEBZ, ZSTEIN

            (21)    | I - Y Y* | / ( n ulp )          DSTEBZ, ZSTEIN

            (22)    | S - Z D Z* | / ( |S| n ulp )    ZSTEDC('I')

            (23)    | I - ZZ* | / ( n ulp )           ZSTEDC('I')

            (24)    | S - Z D Z* | / ( |S| n ulp )    ZSTEDC('V')

            (25)    | I - ZZ* | / ( n ulp )           ZSTEDC('V')

            (26)    | D1 - D2 | / ( |D1| ulp )           ZSTEDC('V') and
                                                         ZSTEDC('N')

            Test 27 is disabled at the moment because ZSTEMR does not
            guarantee high relatvie accuracy.

            (27)    max | D6(i) - WR(i) | / ( |D6(i)| omega ) ,
                     i
                    omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
                                                         ZSTEMR('V', 'A')

            (28)    max | D6(i) - WR(i) | / ( |D6(i)| omega ) ,
                     i
                    omega = 2 (2n-1) ULP (1 + 8 gamma**2) / (1 - gamma)**4
                                                         ZSTEMR('V', 'I')

            Tests 29 through 34 are disable at present because ZSTEMR
            does not handle partial specturm requests.

            (29)    | S - Z D Z* | / ( |S| n ulp )    ZSTEMR('V', 'I')

            (30)    | I - ZZ* | / ( n ulp )           ZSTEMR('V', 'I')

            (31)    ( max { min | WA2(i)-WA3(j) | } +
                       i     j
                      max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
                       i     j
                    ZSTEMR('N', 'I') vs. CSTEMR('V', 'I')

            (32)    | S - Z D Z* | / ( |S| n ulp )    ZSTEMR('V', 'V')

            (33)    | I - ZZ* | / ( n ulp )           ZSTEMR('V', 'V')

            (34)    ( max { min | WA2(i)-WA3(j) | } +
                       i     j
                      max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
                       i     j
                    ZSTEMR('N', 'V') vs. CSTEMR('V', 'V')

            (35)    | S - Z D Z* | / ( |S| n ulp )    ZSTEMR('V', 'A')

            (36)    | I - ZZ* | / ( n ulp )           ZSTEMR('V', 'A')

            (37)    ( max { min | WA2(i)-WA3(j) | } +
                       i     j
                      max { min | WA3(i)-WA2(j) | } ) / ( |D3| ulp )
                       i     j
                    ZSTEMR('N', 'A') vs. CSTEMR('V', 'A')

            The "sizes" are specified by an array NN(1:NSIZES); the value of
            each element 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 diagonal matrix with evenly spaced entries
                 1, ..., ULP  and random signs.
                 (ULP = (first number larger than 1) - 1 )
            (4)  A diagonal matrix with geometrically spaced entries
                 1, ..., ULP  and random signs.
            (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                 and random signs.

            (6)  Same as (4), but multiplied by SQRT( overflow threshold )
            (7)  Same as (4), but multiplied by SQRT( underflow threshold )

            (8)  A matrix of the form  U* D U, where U is unitary and
                 D has evenly spaced entries 1, ..., ULP with random signs
                 on the diagonal.

            (9)  A matrix of the form  U* D U, where U is unitary and
                 D has geometrically spaced entries 1, ..., ULP with random
                 signs on the diagonal.

            (10) A matrix of the form  U* D U, where U is unitary and
                 D has "clustered" entries 1, ULP,..., ULP with random
                 signs on the diagonal.

            (11) Same as (8), but multiplied by SQRT( overflow threshold )
            (12) Same as (8), but multiplied by SQRT( underflow threshold )

            (13) Hermitian matrix with random entries chosen from (-1,1).
            (14) Same as (13), but multiplied by SQRT( overflow threshold )
            (15) Same as (13), but multiplied by SQRT( underflow threshold )
            (16) Same as (8), but diagonal elements are all positive.
            (17) Same as (9), but diagonal elements are all positive.
            (18) Same as (10), but diagonal elements are all positive.
            (19) Same as (16), but multiplied by SQRT( overflow threshold )
            (20) Same as (16), but multiplied by SQRT( underflow threshold )
            (21) A diagonally dominant tridiagonal matrix with geometrically
                 spaced diagonal entries 1, ..., ULP.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZCHKST does nothing.  It must be at least zero.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZCHKST
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZCHKST to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           A

                     A is COMPLEX*16 array of
                                             dimension ( LDA , max(NN) )
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually
                     used.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at
                     least 1 and at least max( NN ).

           AP

                     AP is COMPLEX*16 array of
                                 dimension( max(NN)*max(NN+1)/2 )
                     The matrix A stored in packed format.

           SD

                     SD is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     The diagonal of the tridiagonal matrix computed by ZHETRD.
                     On exit, SD and SE contain the tridiagonal form of the
                     matrix in A.

           SE

                     SE is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     The off-diagonal of the tridiagonal matrix computed by
                     ZHETRD.  On exit, SD and SE contain the tridiagonal form of
                     the matrix in A.

           D1

                     D1 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     The eigenvalues of A, as computed by ZSTEQR simlutaneously
                     with Z.  On exit, the eigenvalues in D1 correspond with the
                     matrix in A.

           D2

                     D2 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     The eigenvalues of A, as computed by ZSTEQR if Z is not
                     computed.  On exit, the eigenvalues in D2 correspond with
                     the matrix in A.

           D3

                     D3 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     The eigenvalues of A, as computed by DSTERF.  On exit, the
                     eigenvalues in D3 correspond with the matrix in A.

           D4

                     D4 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     The eigenvalues of A, as computed by ZPTEQR(V).
                     ZPTEQR factors S as  Z4 D4 Z4*
                     On exit, the eigenvalues in D4 correspond with the matrix in A.

           D5

                     D5 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     The eigenvalues of A, as computed by ZPTEQR(N)
                     when Z is not computed. On exit, the
                     eigenvalues in D4 correspond with the matrix in A.

           WA1

                     WA1 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     All eigenvalues of A, computed to high
                     absolute accuracy, with different range options.
                     as computed by DSTEBZ.

           WA2

                     WA2 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     Selected eigenvalues of A, computed to high
                     absolute accuracy, with different range options.
                     as computed by DSTEBZ.
                     Choose random values for IL and IU, and ask for the
                     IL-th through IU-th eigenvalues.

           WA3

                     WA3 is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     Selected eigenvalues of A, computed to high
                     absolute accuracy, with different range options.
                     as computed by DSTEBZ.
                     Determine the values VL and VU of the IL-th and IU-th
                     eigenvalues and ask for all eigenvalues in this range.

           WR

                     WR is DOUBLE PRECISION array of
                                        dimension( max(NN) )
                     All eigenvalues of A, computed to high
                     absolute accuracy, with different options.
                     as computed by DSTEBZ.

           U

                     U is COMPLEX*16 array of
                                        dimension( LDU, max(NN) ).
                     The unitary matrix computed by ZHETRD + ZUNGTR.

           LDU

                     LDU is INTEGER
                     The leading dimension of U, Z, and V.  It must be at least 1
                     and at least max( NN ).

           V

                     V is COMPLEX*16 array of
                                        dimension( LDU, max(NN) ).
                     The Housholder vectors computed by ZHETRD in reducing A to
                     tridiagonal form.  The vectors computed with UPLO='U' are
                     in the upper triangle, and the vectors computed with UPLO='L'
                     are in the lower triangle.  (As described in ZHETRD, the
                     sub- and superdiagonal are not set to 1, although the
                     true Householder vector has a 1 in that position.  The
                     routines that use V, such as ZUNGTR, set those entries to
                     1 before using them, and then restore them later.)

           VP

                     VP is COMPLEX*16 array of
                                 dimension( max(NN)*max(NN+1)/2 )
                     The matrix V stored in packed format.

           TAU

                     TAU is COMPLEX*16 array of
                                        dimension( max(NN) )
                     The Householder factors computed by ZHETRD in reducing A
                     to tridiagonal form.

           Z

                     Z is COMPLEX*16 array of
                                        dimension( LDU, max(NN) ).
                     The unitary matrix of eigenvectors computed by ZSTEQR,
                     ZPTEQR, and ZSTEIN.

           WORK

                     WORK is COMPLEX*16 array of
                                 dimension( LWORK )

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     1 + 4 * Nmax + 2 * Nmax * lg Nmax + 3 * Nmax**2
                     where Nmax = max( NN(j), 2 ) and lg = log base 2.

           IWORK

                     IWORK is INTEGER array,
                     Workspace.

           LIWORK

                     LIWORK is INTEGER
                     The number of entries in IWORK.  This must be at least
                             6 + 6*Nmax + 5 * Nmax * lg Nmax
                     where Nmax = max( NN(j), 2 ) and lg = log base 2.

           RWORK

                     RWORK is DOUBLE PRECISION array

           LRWORK

                     LRWORK is INTEGER
                     The number of entries in LRWORK (dimension( ??? )

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (26)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           INFO

                     INFO is INTEGER
                     If 0, then everything ran OK.
                      -1: NSIZES < 0
                      -2: Some NN(j) < 0
                      -3: NTYPES < 0
                      -5: THRESH < 0
                      -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
                     -23: LDU < 1 or LDU < NMAX.
                     -29: LWORK too small.
                     If  ZLATMR, CLATMS, ZHETRD, ZUNGTR, ZSTEQR, DSTERF,
                         or ZUNMC2 returns an error code, the
                         absolute value of it is returned.

           -----------------------------------------------------------------------

                  Some Local Variables and Parameters:
                  ---- ----- --------- --- ----------
                  ZERO, ONE       Real 0 and 1.
                  MAXTYP          The number of types defined.
                  NTEST           The number of tests performed, or which can
                                  be performed so far, for the current matrix.
                  NTESTT          The total number of tests performed so far.
                  NBLOCK          Blocksize as returned by ENVIR.
                  NMAX            Largest value in NN.
                  NMATS           The number of matrices generated so far.
                  NERRS           The number of tests which have exceeded THRESH
                                  so far.
                  COND, IMODE     Values to be passed to the matrix generators.
                  ANORM           Norm of A; passed to matrix generators.

                  OVFL, UNFL      Overflow and underflow thresholds.
                  ULP, ULPINV     Finest relative precision and its inverse.
                  RTOVFL, RTUNFL  Square roots of the previous 2 values.
                          The following four arrays decode JTYPE:
                  KTYPE(j)        The general type (1-10) for type "j".
                  KMODE(j)        The MODE value to be passed to the matrix
                                  generator for type "j".
                  KMAGN(j)        The order of magnitude ( O(1),
                                  O(overflow^(1/2) ), O(underflow^(1/2) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zckcsd (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL,
       integer, dimension( * ) QVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
       precision THRESH, integer MMAX, complex*16, dimension( * ) X, complex*16, dimension( * )
       XF, complex*16, dimension( * ) U1, complex*16, dimension( * ) U2, complex*16, dimension( *
       ) V1T, complex*16, dimension( * ) V2T, double precision, dimension( * ) THETA, integer,
       dimension( * ) IWORK, complex*16, dimension( * ) WORK, double precision, dimension( * )
       RWORK, integer NIN, integer NOUT, integer INFO)
       ZCKCSD

       Purpose:

            ZCKCSD tests ZUNCSD:
                   the CSD for an M-by-M unitary matrix X partitioned as
                   [ X11 X12; X21 X22 ]. X11 is P-by-Q.

       Parameters:
           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           PVAL

                     PVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension P.

           QVAL

                     QVAL is INTEGER array, dimension (NM)
                     The values of the matrix column dimension Q.

           NMATS

                     NMATS is INTEGER
                     The number of matrix types to be tested for each combination
                     of matrix dimensions.  If NMATS >= NTYPES (the maximum
                     number of matrix types), then all the different types are
                     generated for testing.  If NMATS < NTYPES, another input line
                     is read to get the numbers of the matrix types to be used.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry, the seed of the random number generator.  The array
                     elements should be between 0 and 4095, otherwise they will be
                     reduced mod 4096, and ISEED(4) must be odd.
                     On exit, the next seed in the random number sequence after
                     all the test matrices have been generated.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           MMAX

                     MMAX is INTEGER
                     The maximum value permitted for M, used in dimensioning the
                     work arrays.

           X

                     X is COMPLEX*16 array, dimension (MMAX*MMAX)

           XF

                     XF is COMPLEX*16 array, dimension (MMAX*MMAX)

           U1

                     U1 is COMPLEX*16 array, dimension (MMAX*MMAX)

           U2

                     U2 is COMPLEX*16 array, dimension (MMAX*MMAX)

           V1T

                     V1T is COMPLEX*16 array, dimension (MMAX*MMAX)

           V2T

                     V2T is COMPLEX*16 array, dimension (MMAX*MMAX)

           THETA

                     THETA is DOUBLE PRECISION array, dimension (MMAX)

           IWORK

                     IWORK is INTEGER array, dimension (MMAX)

           WORK

                     WORK is COMPLEX*16 array

           RWORK

                     RWORK is DOUBLE PRECISION array

           NIN

                     NIN is INTEGER
                     The unit number for input.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

           INFO

                     INFO is INTEGER
                     = 0 :  successful exit
                     > 0 :  If ZLAROR returns an error code, the absolute value
                            of it is returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zckglm (integer NN, integer, dimension( * ) NVAL, integer, dimension( * ) MVAL,
       integer, dimension( * ) PVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
       precision THRESH, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * )
       AF, complex*16, dimension( * ) B, complex*16, dimension( * ) BF, complex*16, dimension( *
       ) X, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN,
       integer NOUT, integer INFO)
       ZCKGLM

       Purpose:

            ZCKGLM tests ZGGGLM - subroutine for solving generalized linear
                                  model problem.

       Parameters:
           NN

                     NN is INTEGER
                     The number of values of N, M and P contained in the vectors
                     NVAL, MVAL and PVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix row dimension N.

           MVAL

                     MVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension M.

           PVAL

                     PVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension P.

           NMATS

                     NMATS is INTEGER
                     The number of matrix types to be tested for each combination
                     of matrix dimensions.  If NMATS >= NTYPES (the maximum
                     number of matrix types), then all the different types are
                     generated for testing.  If NMATS < NTYPES, another input line
                     is read to get the numbers of the matrix types to be used.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry, the seed of the random number generator.  The array
                     elements should be between 0 and 4095, otherwise they will be
                     reduced mod 4096, and ISEED(4) must be odd.
                     On exit, the next seed in the random number sequence after
                     all the test matrices have been generated.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESID >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NMAX)

           BF

                     BF is COMPLEX*16 array, dimension (NMAX*NMAX)

           X

                     X is COMPLEX*16 array, dimension (4*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           NIN

                     NIN is INTEGER
                     The unit number for input.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

           INFO

                     INFO is INTEGER
                     = 0 :  successful exit
                     > 0 :  If ZLATMS returns an error code, the absolute value
                            of it is returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zckgqr (integer NM, integer, dimension( * ) MVAL, integer NP, integer, dimension( *
       ) PVAL, integer NN, integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 )
       ISEED, double precision THRESH, integer NMAX, complex*16, dimension( * ) A, complex*16,
       dimension( * ) AF, complex*16, dimension( * ) AQ, complex*16, dimension( * ) AR,
       complex*16, dimension( * ) TAUA, complex*16, dimension( * ) B, complex*16, dimension( * )
       BF, complex*16, dimension( * ) BZ, complex*16, dimension( * ) BT, complex*16, dimension( *
       ) BWK, complex*16, dimension( * ) TAUB, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
       ZCKGQR

       Purpose:

            ZCKGQR tests
            ZGGQRF: GQR factorization for N-by-M matrix A and N-by-P matrix B,
            ZGGRQF: GRQ factorization for M-by-N matrix A and P-by-N matrix B.

       Parameters:
           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row(column) dimension M.

           NP

                     NP is INTEGER
                     The number of values of P contained in the vector PVAL.

           PVAL

                     PVAL is INTEGER array, dimension (NP)
                     The values of the matrix row(column) dimension P.

           NN

                     NN is INTEGER
                     The number of values of N contained in the vector NVAL.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column(row) dimension N.

           NMATS

                     NMATS is INTEGER
                     The number of matrix types to be tested for each combination
                     of matrix dimensions.  If NMATS >= NTYPES (the maximum
                     number of matrix types), then all the different types are
                     generated for testing.  If NMATS < NTYPES, another input line
                     is read to get the numbers of the matrix types to be used.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry, the seed of the random number generator.  The array
                     elements should be between 0 and 4095, otherwise they will be
                     reduced mod 4096, and ISEED(4) must be odd.
                     On exit, the next seed in the random number sequence after
                     all the test matrices have been generated.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           AQ

                     AQ is COMPLEX*16 array, dimension (NMAX*NMAX)

           AR

                     AR is COMPLEX*16 array, dimension (NMAX*NMAX)

           TAUA

                     TAUA is COMPLEX*16 array, dimension (NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NMAX)

           BF

                     BF is COMPLEX*16 array, dimension (NMAX*NMAX)

           BZ

                     BZ is COMPLEX*16 array, dimension (NMAX*NMAX)

           BT

                     BT is COMPLEX*16 array, dimension (NMAX*NMAX)

           BWK

                     BWK is COMPLEX*16 array, dimension (NMAX*NMAX)

           TAUB

                     TAUB is COMPLEX*16 array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           NIN

                     NIN is INTEGER
                     The unit number for input.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

           INFO

                     INFO is INTEGER
                     = 0 :  successful exit
                     > 0 :  If ZLATMS returns an error code, the absolute value
                            of it is returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zckgsv (integer NM, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL,
       integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
       precision THRESH, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * )
       AF, complex*16, dimension( * ) B, complex*16, dimension( * ) BF, complex*16, dimension( *
       ) U, complex*16, dimension( * ) V, complex*16, dimension( * ) Q, double precision,
       dimension( * ) ALPHA, double precision, dimension( * ) BETA, complex*16, dimension( * ) R,
       integer, dimension( * ) IWORK, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, integer NIN, integer NOUT, integer INFO)
       ZCKGSV

       Purpose:

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

       Parameters:
           NM

                     NM is INTEGER
                     The number of values of M contained in the vector MVAL.

           MVAL

                     MVAL is INTEGER array, dimension (NM)
                     The values of the matrix row dimension M.

           PVAL

                     PVAL is INTEGER array, dimension (NP)
                     The values of the matrix row dimension P.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column dimension N.

           NMATS

                     NMATS is INTEGER
                     The number of matrix types to be tested for each combination
                     of matrix dimensions.  If NMATS >= NTYPES (the maximum
                     number of matrix types), then all the different types are
                     generated for testing.  If NMATS < NTYPES, another input line
                     is read to get the numbers of the matrix types to be used.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry, the seed of the random number generator.  The array
                     elements should be between 0 and 4095, otherwise they will be
                     reduced mod 4096, and ISEED(4) must be odd.
                     On exit, the next seed in the random number sequence after
                     all the test matrices have been generated.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NMAX)

           BF

                     BF is COMPLEX*16 array, dimension (NMAX*NMAX)

           U

                     U is COMPLEX*16 array, dimension (NMAX*NMAX)

           V

                     V is COMPLEX*16 array, dimension (NMAX*NMAX)

           Q

                     Q is COMPLEX*16 array, dimension (NMAX*NMAX)

           ALPHA

                     ALPHA is DOUBLE PRECISION array, dimension (NMAX)

           BETA

                     BETA is DOUBLE PRECISION array, dimension (NMAX)

           R

                     R is COMPLEX*16 array, dimension (NMAX*NMAX)

           IWORK

                     IWORK is INTEGER array, dimension (NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           NIN

                     NIN is INTEGER
                     The unit number for input.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

           INFO

                     INFO is INTEGER
                     = 0 :  successful exit
                     > 0 :  If ZLATMS returns an error code, the absolute value
                            of it is returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zcklse (integer NN, integer, dimension( * ) MVAL, integer, dimension( * ) PVAL,
       integer, dimension( * ) NVAL, integer NMATS, integer, dimension( 4 ) ISEED, double
       precision THRESH, integer NMAX, complex*16, dimension( * ) A, complex*16, dimension( * )
       AF, complex*16, dimension( * ) B, complex*16, dimension( * ) BF, complex*16, dimension( *
       ) X, complex*16, dimension( * ) WORK, double precision, dimension( * ) RWORK, integer NIN,
       integer NOUT, integer INFO)
       ZCKLSE

       Purpose:

            ZCKLSE tests ZGGLSE - a subroutine for solving linear equality
            constrained least square problem (LSE).

       Parameters:
           NN

                     NN is INTEGER
                     The number of values of (M,P,N) contained in the vectors
                     (MVAL, PVAL, NVAL).

           MVAL

                     MVAL is INTEGER array, dimension (NN)
                     The values of the matrix row(column) dimension M.

           PVAL

                     PVAL is INTEGER array, dimension (NN)
                     The values of the matrix row(column) dimension P.

           NVAL

                     NVAL is INTEGER array, dimension (NN)
                     The values of the matrix column(row) dimension N.

           NMATS

                     NMATS is INTEGER
                     The number of matrix types to be tested for each combination
                     of matrix dimensions.  If NMATS >= NTYPES (the maximum
                     number of matrix types), then all the different types are
                     generated for testing.  If NMATS < NTYPES, another input line
                     is read to get the numbers of the matrix types to be used.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry, the seed of the random number generator.  The array
                     elements should be between 0 and 4095, otherwise they will be
                     reduced mod 4096, and ISEED(4) must be odd.
                     On exit, the next seed in the random number sequence after
                     all the test matrices have been generated.

           THRESH

                     THRESH is DOUBLE PRECISION
                     The threshold value for the test ratios.  A result is
                     included in the output file if RESULT >= THRESH.  To have
                     every test ratio printed, use THRESH = 0.

           NMAX

                     NMAX is INTEGER
                     The maximum value permitted for M or N, used in dimensioning
                     the work arrays.

           A

                     A is COMPLEX*16 array, dimension (NMAX*NMAX)

           AF

                     AF is COMPLEX*16 array, dimension (NMAX*NMAX)

           B

                     B is COMPLEX*16 array, dimension (NMAX*NMAX)

           BF

                     BF is COMPLEX*16 array, dimension (NMAX*NMAX)

           X

                     X is COMPLEX*16 array, dimension (5*NMAX)

           WORK

                     WORK is COMPLEX*16 array, dimension (NMAX*NMAX)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (NMAX)

           NIN

                     NIN is INTEGER
                     The unit number for input.

           NOUT

                     NOUT is INTEGER
                     The unit number for output.

           INFO

                     INFO is INTEGER
                     = 0 :  successful exit
                     > 0 :  If ZLATMS returns an error code, the absolute value
                            of it is returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zcsdts (integer M, integer P, integer Q, complex*16, dimension( ldx, * ) X,
       complex*16, dimension( ldx, * ) XF, integer LDX, complex*16, dimension( ldu1, * ) U1,
       integer LDU1, complex*16, dimension( ldu2, * ) U2, integer LDU2, complex*16, dimension(
       ldv1t, * ) V1T, integer LDV1T, complex*16, dimension( ldv2t, * ) V2T, integer LDV2T,
       double precision, dimension( * ) THETA, integer, dimension( * ) IWORK, complex*16,
       dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double
       precision, dimension( 15 ) RESULT)
       ZCSDTS

       Purpose:

            ZCSDTS tests ZUNCSD, which, given an M-by-M partitioned unitary
            matrix X,
                         Q  M-Q
                  X = [ X11 X12 ] P   ,
                      [ X21 X22 ] M-P

            computes the CSD

                  [ U1    ]**T * [ X11 X12 ] * [ V1    ]
                  [    U2 ]      [ X21 X22 ]   [    V2 ]

                                        [  I  0  0 |  0  0  0 ]
                                        [  0  C  0 |  0 -S  0 ]
                                        [  0  0  0 |  0  0 -I ]
                                      = [---------------------] = [ D11 D12 ] .
                                        [  0  0  0 |  I  0  0 ]   [ D21 D22 ]
                                        [  0  S  0 |  0  C  0 ]
                                        [  0  0  I |  0  0  0 ]

            and also SORCSD2BY1, which, given
                     Q
                  [ X11 ] P   ,
                  [ X21 ] M-P

            computes the 2-by-1 CSD

                                                [  I  0  0 ]
                                                [  0  C  0 ]
                                                [  0  0  0 ]
                  [ U1    ]**T * [ X11 ] * V1 = [----------] = [ D11 ] ,
                  [    U2 ]      [ X21 ]        [  0  0  0 ]   [ D21 ]
                                                [  0  S  0 ]
                                                [  0  0  I ]

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrix X.  M >= 0.

           P

                     P is INTEGER
                     The number of rows of the matrix X11.  P >= 0.

           Q

                     Q is INTEGER
                     The number of columns of the matrix X11.  Q >= 0.

           X

                     X is COMPLEX*16 array, dimension (LDX,M)
                     The M-by-M matrix X.

           XF

                     XF is COMPLEX*16 array, dimension (LDX,M)
                     Details of the CSD of X, as returned by ZUNCSD;
                     see ZUNCSD for further details.

           LDX

                     LDX is INTEGER
                     The leading dimension of the arrays X and XF.
                     LDX >= max( 1,M ).

           U1

                     U1 is COMPLEX*16 array, dimension(LDU1,P)
                     The P-by-P unitary matrix U1.

           LDU1

                     LDU1 is INTEGER
                     The leading dimension of the array U1. LDU >= max(1,P).

           U2

                     U2 is COMPLEX*16 array, dimension(LDU2,M-P)
                     The (M-P)-by-(M-P) unitary matrix U2.

           LDU2

                     LDU2 is INTEGER
                     The leading dimension of the array U2. LDU >= max(1,M-P).

           V1T

                     V1T is COMPLEX*16 array, dimension(LDV1T,Q)
                     The Q-by-Q unitary matrix V1T.

           LDV1T

                     LDV1T is INTEGER
                     The leading dimension of the array V1T. LDV1T >=
                     max(1,Q).

           V2T

                     V2T is COMPLEX*16 array, dimension(LDV2T,M-Q)
                     The (M-Q)-by-(M-Q) unitary matrix V2T.

           LDV2T

                     LDV2T is INTEGER
                     The leading dimension of the array V2T. LDV2T >=
                     max(1,M-Q).

           THETA

                     THETA is DOUBLE PRECISION array, dimension MIN(P,M-P,Q,M-Q)
                     The CS values of X; the essentially diagonal matrices C and
                     S are constructed from THETA; see subroutine ZUNCSD for
                     details.

           IWORK

                     IWORK is INTEGER array, dimension (M)

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK

           RWORK

                     RWORK is DOUBLE PRECISION array

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (15)
                     The test ratios:
                     First, the 2-by-2 CSD:
                     RESULT(1) = norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 )
                     RESULT(2) = norm( U1'*X12*V2 - D12 ) / ( MAX(1,P,M-Q)*EPS2 )
                     RESULT(3) = norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 )
                     RESULT(4) = norm( U2'*X22*V2 - D22 ) / ( MAX(1,M-P,M-Q)*EPS2 )
                     RESULT(5) = norm( I - U1'*U1 ) / ( MAX(1,P)*ULP )
                     RESULT(6) = norm( I - U2'*U2 ) / ( MAX(1,M-P)*ULP )
                     RESULT(7) = norm( I - V1T'*V1T ) / ( MAX(1,Q)*ULP )
                     RESULT(8) = norm( I - V2T'*V2T ) / ( MAX(1,M-Q)*ULP )
                     RESULT(9) = 0        if THETA is in increasing order and
                                          all angles are in [0,pi/2];
                               = ULPINV   otherwise.
                     Then, the 2-by-1 CSD:
                     RESULT(10) = norm( U1'*X11*V1 - D11 ) / ( MAX(1,P,Q)*EPS2 )
                     RESULT(11) = norm( U2'*X21*V1 - D21 ) / ( MAX(1,M-P,Q)*EPS2 )
                     RESULT(12) = norm( I - U1'*U1 ) / ( MAX(1,P)*ULP )
                     RESULT(13) = norm( I - U2'*U2 ) / ( MAX(1,M-P)*ULP )
                     RESULT(14) = norm( I - V1T'*V1T ) / ( MAX(1,Q)*ULP )
                     RESULT(15) = 0        if THETA is in increasing order and
                                           all angles are in [0,pi/2];
                                = ULPINV   otherwise.
                     ( EPS2 = MAX( norm( I - X'*X ) / M, ULP ). )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zdrges (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
       complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
       dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
       dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( * ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 13 )
       RESULT, logical, dimension( * ) BWORK, integer INFO)
       ZDRGES

       Purpose:

            ZDRGES checks the nonsymmetric generalized eigenvalue (Schur form)
            problem driver ZGGES.

            ZGGES factors A and B as Q*S*Z'  and Q*T*Z' , where ' means conjugate
            transpose, S and T are  upper triangular (i.e., in generalized Schur
            form), and Q and Z are unitary. It also computes the generalized
            eigenvalues (alpha(j),beta(j)), j=1,...,n.  Thus,
            w(j) = alpha(j)/beta(j) is a root of the characteristic equation

                            det( A - w(j) B ) = 0

            Optionally it also reorder the eigenvalues so that a selected
            cluster of eigenvalues appears in the leading diagonal block of the
            Schur forms.

            When ZDRGES is called, a number of matrix "sizes" ("N's") and a
            number of matrix "TYPES" are specified.  For each size ("N")
            and each TYPE of matrix, a pair of matrices (A, B) will be generated
            and used for testing. For each matrix pair, the following 13 tests
            will be performed and compared with the threshold THRESH except
            the tests (5), (11) and (13).

            (1)   | A - Q S Z' | / ( |A| n ulp ) (no sorting of eigenvalues)

            (2)   | B - Q T Z' | / ( |B| n ulp ) (no sorting of eigenvalues)

            (3)   | I - QQ' | / ( n ulp ) (no sorting of eigenvalues)

            (4)   | I - ZZ' | / ( n ulp ) (no sorting of eigenvalues)

            (5)   if A is in Schur form (i.e. triangular form) (no sorting of
                  eigenvalues)

            (6)   if eigenvalues = diagonal elements of the Schur form (S, T),
                  i.e., test the maximum over j of D(j)  where:

                                |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
                      D(j) = ------------------------ + -----------------------
                             max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)

                  (no sorting of eigenvalues)

            (7)   | (A,B) - Q (S,T) Z' | / ( |(A,B)| n ulp )
                  (with sorting of eigenvalues).

            (8)   | I - QQ' | / ( n ulp ) (with sorting of eigenvalues).

            (9)   | I - ZZ' | / ( n ulp ) (with sorting of eigenvalues).

            (10)  if A is in Schur form (i.e. quasi-triangular form)
                  (with sorting of eigenvalues).

            (11)  if eigenvalues = diagonal elements of the Schur form (S, T),
                  i.e. test the maximum over j of D(j)  where:

                                |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
                      D(j) = ------------------------ + -----------------------
                             max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)

                  (with sorting of eigenvalues).

            (12)  if sorting worked and SDIM is the number of eigenvalues
                  which were CELECTed.

            Test Matrices
            =============

            The sizes of the test matrices are specified by an array
            NN(1:NSIZES); the value of each element 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)  ( 0, 0 )         (a pair of zero matrices)

            (2)  ( I, 0 )         (an identity and a zero matrix)

            (3)  ( 0, I )         (an identity and a zero matrix)

            (4)  ( I, I )         (a pair of identity matrices)

                    t   t
            (5)  ( J , J  )       (a pair of transposed Jordan blocks)

                                                t                ( I   0  )
            (6)  ( X, Y )         where  X = ( J   0  )  and Y = (      t )
                                             ( 0   I  )          ( 0   J  )
                                  and I is a k x k identity and J a (k+1)x(k+1)
                                  Jordan block; k=(N-1)/2

            (7)  ( D, I )         where D is diag( 0, 1,..., N-1 ) (a diagonal
                                  matrix with those diagonal entries.)
            (8)  ( I, D )

            (9)  ( big*D, small*I ) where "big" is near overflow and small=1/big

            (10) ( small*D, big*I )

            (11) ( big*I, small*D )

            (12) ( small*I, big*D )

            (13) ( big*D, big*I )

            (14) ( small*D, small*I )

            (15) ( D1, D2 )        where D1 is diag( 0, 0, 1, ..., N-3, 0 ) and
                                   D2 is diag( 0, N-3, N-4,..., 1, 0, 0 )
                      t   t
            (16) Q ( J , J ) Z     where Q and Z are random orthogonal matrices.

            (17) Q ( T1, T2 ) Z    where T1 and T2 are upper triangular matrices
                                   with random O(1) entries above the diagonal
                                   and diagonal entries diag(T1) =
                                   ( 0, 0, 1, ..., N-3, 0 ) and diag(T2) =
                                   ( 0, N-3, N-4,..., 1, 0, 0 )

            (18) Q ( T1, T2 ) Z    diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1,..., 1, 0 )
                                   s = machine precision.

            (19) Q ( T1, T2 ) Z    diag(T1)=( 0,0,1,1, 1-d, ..., 1-(N-5)*d=s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )

                                                                   N-5
            (20) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, 1, a, ..., a   =s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )

            (21) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, r1, r2, ..., r(N-4), 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
                                   where r1,..., r(N-4) are random.

            (22) Q ( big*T1, small*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (23) Q ( small*T1, big*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (24) Q ( small*T1, small*T2 ) Z  diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (25) Q ( big*T1, big*T2 ) Z      diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (26) Q ( T1, T2 ) Z     where T1 and T2 are random upper-triangular
                                    matrices.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     DDRGES does nothing.  NSIZES >= 0.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  NN >= 0.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, DDRGES
                     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 matrix is in A on input.
                     This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 DDRGES to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.  THRESH >= 0.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original A matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, B, S, and T.
                     It must be at least 1 and at least max( NN ).

           B

                     B is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original B matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           S

                     S is COMPLEX*16 array, dimension (LDA, max(NN))
                     The Schur form matrix computed from A by ZGGES.  On exit, S
                     contains the Schur form matrix corresponding to the matrix
                     in A.

           T

                     T is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper triangular matrix computed from B by ZGGES.

           Q

                     Q is COMPLEX*16 array, dimension (LDQ, max(NN))
                     The (left) orthogonal matrix computed by ZGGES.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of Q and Z. It must
                     be at least 1 and at least max( NN ).

           Z

                     Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
                     The (right) orthogonal matrix computed by ZGGES.

           ALPHA

                     ALPHA is COMPLEX*16 array, dimension (max(NN))

           BETA

                     BETA is COMPLEX*16 array, dimension (max(NN))

                     The generalized eigenvalues of (A,B) computed by ZGGES.
                     ALPHA(k) / BETA(k) is the k-th generalized eigenvalue of A
                     and B.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.  LWORK >= 3*N*N.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension ( 8*N )
                     Real workspace.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (15)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid overflow.

           BWORK

                     BWORK is LOGICAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  A routine returned an error code.  INFO is the
                           absolute value of the INFO value returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrges3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
       complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
       dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
       dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( * ) WORK,
       integer LWORK, double precision, dimension( * ) RWORK, double precision, dimension( 13 )
       RESULT, logical, dimension( * ) BWORK, integer INFO)
       ZDRGES3

       Purpose:

            ZDRGES3 checks the nonsymmetric generalized eigenvalue (Schur form)
            problem driver ZGGES3.

            ZGGES3 factors A and B as Q*S*Z'  and Q*T*Z' , where ' means conjugate
            transpose, S and T are  upper triangular (i.e., in generalized Schur
            form), and Q and Z are unitary. It also computes the generalized
            eigenvalues (alpha(j),beta(j)), j=1,...,n.  Thus,
            w(j) = alpha(j)/beta(j) is a root of the characteristic equation

                            det( A - w(j) B ) = 0

            Optionally it also reorder the eigenvalues so that a selected
            cluster of eigenvalues appears in the leading diagonal block of the
            Schur forms.

            When ZDRGES3 is called, a number of matrix "sizes" ("N's") and a
            number of matrix "TYPES" are specified.  For each size ("N")
            and each TYPE of matrix, a pair of matrices (A, B) will be generated
            and used for testing. For each matrix pair, the following 13 tests
            will be performed and compared with the threshold THRESH except
            the tests (5), (11) and (13).

            (1)   | A - Q S Z' | / ( |A| n ulp ) (no sorting of eigenvalues)

            (2)   | B - Q T Z' | / ( |B| n ulp ) (no sorting of eigenvalues)

            (3)   | I - QQ' | / ( n ulp ) (no sorting of eigenvalues)

            (4)   | I - ZZ' | / ( n ulp ) (no sorting of eigenvalues)

            (5)   if A is in Schur form (i.e. triangular form) (no sorting of
                  eigenvalues)

            (6)   if eigenvalues = diagonal elements of the Schur form (S, T),
                  i.e., test the maximum over j of D(j)  where:

                                |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
                      D(j) = ------------------------ + -----------------------
                             max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)

                  (no sorting of eigenvalues)

            (7)   | (A,B) - Q (S,T) Z' | / ( |(A,B)| n ulp )
                  (with sorting of eigenvalues).

            (8)   | I - QQ' | / ( n ulp ) (with sorting of eigenvalues).

            (9)   | I - ZZ' | / ( n ulp ) (with sorting of eigenvalues).

            (10)  if A is in Schur form (i.e. quasi-triangular form)
                  (with sorting of eigenvalues).

            (11)  if eigenvalues = diagonal elements of the Schur form (S, T),
                  i.e. test the maximum over j of D(j)  where:

                                |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
                      D(j) = ------------------------ + -----------------------
                             max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)

                  (with sorting of eigenvalues).

            (12)  if sorting worked and SDIM is the number of eigenvalues
                  which were CELECTed.

            Test Matrices
            =============

            The sizes of the test matrices are specified by an array
            NN(1:NSIZES); the value of each element 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)  ( 0, 0 )         (a pair of zero matrices)

            (2)  ( I, 0 )         (an identity and a zero matrix)

            (3)  ( 0, I )         (an identity and a zero matrix)

            (4)  ( I, I )         (a pair of identity matrices)

                    t   t
            (5)  ( J , J  )       (a pair of transposed Jordan blocks)

                                                t                ( I   0  )
            (6)  ( X, Y )         where  X = ( J   0  )  and Y = (      t )
                                             ( 0   I  )          ( 0   J  )
                                  and I is a k x k identity and J a (k+1)x(k+1)
                                  Jordan block; k=(N-1)/2

            (7)  ( D, I )         where D is diag( 0, 1,..., N-1 ) (a diagonal
                                  matrix with those diagonal entries.)
            (8)  ( I, D )

            (9)  ( big*D, small*I ) where "big" is near overflow and small=1/big

            (10) ( small*D, big*I )

            (11) ( big*I, small*D )

            (12) ( small*I, big*D )

            (13) ( big*D, big*I )

            (14) ( small*D, small*I )

            (15) ( D1, D2 )        where D1 is diag( 0, 0, 1, ..., N-3, 0 ) and
                                   D2 is diag( 0, N-3, N-4,..., 1, 0, 0 )
                      t   t
            (16) Q ( J , J ) Z     where Q and Z are random orthogonal matrices.

            (17) Q ( T1, T2 ) Z    where T1 and T2 are upper triangular matrices
                                   with random O(1) entries above the diagonal
                                   and diagonal entries diag(T1) =
                                   ( 0, 0, 1, ..., N-3, 0 ) and diag(T2) =
                                   ( 0, N-3, N-4,..., 1, 0, 0 )

            (18) Q ( T1, T2 ) Z    diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1,..., 1, 0 )
                                   s = machine precision.

            (19) Q ( T1, T2 ) Z    diag(T1)=( 0,0,1,1, 1-d, ..., 1-(N-5)*d=s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )

                                                                   N-5
            (20) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, 1, a, ..., a   =s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )

            (21) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, r1, r2, ..., r(N-4), 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
                                   where r1,..., r(N-4) are random.

            (22) Q ( big*T1, small*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (23) Q ( small*T1, big*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (24) Q ( small*T1, small*T2 ) Z  diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (25) Q ( big*T1, big*T2 ) Z      diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (26) Q ( T1, T2 ) Z     where T1 and T2 are random upper-triangular
                                    matrices.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     DDRGES3 does nothing.  NSIZES >= 0.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  NN >= 0.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, DDRGES3
                     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 matrix is in A on input.
                     This is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 DDRGES3 to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.  THRESH >= 0.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original A matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, B, S, and T.
                     It must be at least 1 and at least max( NN ).

           B

                     B is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original B matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           S

                     S is COMPLEX*16 array, dimension (LDA, max(NN))
                     The Schur form matrix computed from A by ZGGES3.  On exit, S
                     contains the Schur form matrix corresponding to the matrix
                     in A.

           T

                     T is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper triangular matrix computed from B by ZGGES3.

           Q

                     Q is COMPLEX*16 array, dimension (LDQ, max(NN))
                     The (left) orthogonal matrix computed by ZGGES3.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of Q and Z. It must
                     be at least 1 and at least max( NN ).

           Z

                     Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
                     The (right) orthogonal matrix computed by ZGGES3.

           ALPHA

                     ALPHA is COMPLEX*16 array, dimension (max(NN))

           BETA

                     BETA is COMPLEX*16 array, dimension (max(NN))

                     The generalized eigenvalues of (A,B) computed by ZGGES3.
                     ALPHA(k) / BETA(k) is the k-th generalized eigenvalue of A
                     and B.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.  LWORK >= 3*N*N.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension ( 8*N )
                     Real workspace.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (15)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid overflow.

           BWORK

                     BWORK is LOGICAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  A routine returned an error code.  INFO is the
                           absolute value of the INFO value returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           February 2015

   subroutine zdrgev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
       complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
       dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
       dimension( ldqe, * ) QE, integer LDQE, complex*16, dimension( * ) ALPHA, complex*16,
       dimension( * ) BETA, complex*16, dimension( * ) ALPHA1, complex*16, dimension( * ) BETA1,
       complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK,
       double precision, dimension( * ) RESULT, integer INFO)
       ZDRGEV

       Purpose:

            ZDRGEV checks the nonsymmetric generalized eigenvalue problem driver
            routine ZGGEV.

            ZGGEV computes for a pair of n-by-n nonsymmetric matrices (A,B) the
            generalized eigenvalues and, optionally, the left and right
            eigenvectors.

            A generalized eigenvalue for a pair of matrices (A,B) is a scalar w
            or a ratio  alpha/beta = w, such that A - w*B is singular.  It is
            usually represented as the pair (alpha,beta), as there is reasonable
            interpretation for beta=0, and even for both being zero.

            A right generalized eigenvector corresponding to a generalized
            eigenvalue  w  for a pair of matrices (A,B) is a vector r  such that
            (A - wB) * r = 0.  A left generalized eigenvector is a vector l such
            that l**H * (A - wB) = 0, where l**H is the conjugate-transpose of l.

            When ZDRGEV is called, a number of matrix "sizes" ("n's") and a
            number of matrix "types" are specified.  For each size ("n")
            and each type of matrix, a pair of matrices (A, B) will be generated
            and used for testing.  For each matrix pair, the following tests
            will be performed and compared with the threshold THRESH.

            Results from ZGGEV:

            (1)  max over all left eigenvalue/-vector pairs (alpha/beta,l) of

                 | VL**H * (beta A - alpha B) |/( ulp max(|beta A|, |alpha B|) )

                 where VL**H is the conjugate-transpose of VL.

            (2)  | |VL(i)| - 1 | / ulp and whether largest component real

                 VL(i) denotes the i-th column of VL.

            (3)  max over all left eigenvalue/-vector pairs (alpha/beta,r) of

                 | (beta A - alpha B) * VR | / ( ulp max(|beta A|, |alpha B|) )

            (4)  | |VR(i)| - 1 | / ulp and whether largest component real

                 VR(i) denotes the i-th column of VR.

            (5)  W(full) = W(partial)
                 W(full) denotes the eigenvalues computed when both l and r
                 are also computed, and W(partial) denotes the eigenvalues
                 computed when only W, only W and r, or only W and l are
                 computed.

            (6)  VL(full) = VL(partial)
                 VL(full) denotes the left eigenvectors computed when both l
                 and r are computed, and VL(partial) denotes the result
                 when only l is computed.

            (7)  VR(full) = VR(partial)
                 VR(full) denotes the right eigenvectors computed when both l
                 and r are also computed, and VR(partial) denotes the result
                 when only l is computed.

            Test Matrices
            ---- --------

            The sizes of the test matrices are specified by an array
            NN(1:NSIZES); the value of each element 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)  ( 0, 0 )         (a pair of zero matrices)

            (2)  ( I, 0 )         (an identity and a zero matrix)

            (3)  ( 0, I )         (an identity and a zero matrix)

            (4)  ( I, I )         (a pair of identity matrices)

                    t   t
            (5)  ( J , J  )       (a pair of transposed Jordan blocks)

                                                t                ( I   0  )
            (6)  ( X, Y )         where  X = ( J   0  )  and Y = (      t )
                                             ( 0   I  )          ( 0   J  )
                                  and I is a k x k identity and J a (k+1)x(k+1)
                                  Jordan block; k=(N-1)/2

            (7)  ( D, I )         where D is diag( 0, 1,..., N-1 ) (a diagonal
                                  matrix with those diagonal entries.)
            (8)  ( I, D )

            (9)  ( big*D, small*I ) where "big" is near overflow and small=1/big

            (10) ( small*D, big*I )

            (11) ( big*I, small*D )

            (12) ( small*I, big*D )

            (13) ( big*D, big*I )

            (14) ( small*D, small*I )

            (15) ( D1, D2 )        where D1 is diag( 0, 0, 1, ..., N-3, 0 ) and
                                   D2 is diag( 0, N-3, N-4,..., 1, 0, 0 )
                      t   t
            (16) Q ( J , J ) Z     where Q and Z are random orthogonal matrices.

            (17) Q ( T1, T2 ) Z    where T1 and T2 are upper triangular matrices
                                   with random O(1) entries above the diagonal
                                   and diagonal entries diag(T1) =
                                   ( 0, 0, 1, ..., N-3, 0 ) and diag(T2) =
                                   ( 0, N-3, N-4,..., 1, 0, 0 )

            (18) Q ( T1, T2 ) Z    diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1,..., 1, 0 )
                                   s = machine precision.

            (19) Q ( T1, T2 ) Z    diag(T1)=( 0,0,1,1, 1-d, ..., 1-(N-5)*d=s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )

                                                                   N-5
            (20) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, 1, a, ..., a   =s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )

            (21) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, r1, r2, ..., r(N-4), 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
                                   where r1,..., r(N-4) are random.

            (22) Q ( big*T1, small*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (23) Q ( small*T1, big*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (24) Q ( small*T1, small*T2 ) Z  diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (25) Q ( big*T1, big*T2 ) Z      diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (26) Q ( T1, T2 ) Z     where T1 and T2 are random upper-triangular
                                    matrices.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZDRGES does nothing.  NSIZES >= 0.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  NN >= 0.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZDRGEV
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZDRGES to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IERR not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original A matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, B, S, and T.
                     It must be at least 1 and at least max( NN ).

           B

                     B is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original B matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           S

                     S is COMPLEX*16 array, dimension (LDA, max(NN))
                     The Schur form matrix computed from A by ZGGEV.  On exit, S
                     contains the Schur form matrix corresponding to the matrix
                     in A.

           T

                     T is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper triangular matrix computed from B by ZGGEV.

           Q

                     Q is COMPLEX*16 array, dimension (LDQ, max(NN))
                     The (left) eigenvectors matrix computed by ZGGEV.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of Q and Z. It must
                     be at least 1 and at least max( NN ).

           Z

                     Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
                     The (right) orthogonal matrix computed by ZGGEV.

           QE

                     QE is COMPLEX*16 array, dimension( LDQ, max(NN) )
                     QE holds the computed right or left eigenvectors.

           LDQE

                     LDQE is INTEGER
                     The leading dimension of QE. LDQE >= max(1,max(NN)).

           ALPHA

                     ALPHA is COMPLEX*16 array, dimension (max(NN))

           BETA

                     BETA is COMPLEX*16 array, dimension (max(NN))

                     The generalized eigenvalues of (A,B) computed by ZGGEV.
                     ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
                     generalized eigenvalue of A and B.

           ALPHA1

                     ALPHA1 is COMPLEX*16 array, dimension (max(NN))

           BETA1

                     BETA1 is COMPLEX*16 array, dimension (max(NN))

                     Like ALPHAR, ALPHAI, BETA, these arrays contain the
                     eigenvalues of A and B, but those computed when ZGGEV only
                     computes a partial eigendecomposition, i.e. not the
                     eigenvalues and left and right eigenvectors.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  LWORK >= N*(N+1)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (8*N)
                     Real workspace.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid overflow.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  A routine returned an error code.  INFO is the
                           absolute value of the INFO value returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zdrgev3 (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
       complex*16, dimension( lda, * ) S, complex*16, dimension( lda, * ) T, complex*16,
       dimension( ldq, * ) Q, integer LDQ, complex*16, dimension( ldq, * ) Z, complex*16,
       dimension( ldqe, * ) QE, integer LDQE, complex*16, dimension( * ) ALPHA, complex*16,
       dimension( * ) BETA, complex*16, dimension( * ) ALPHA1, complex*16, dimension( * ) BETA1,
       complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK,
       double precision, dimension( * ) RESULT, integer INFO)
       ZDRGEV3

       Purpose:

            ZDRGEV3 checks the nonsymmetric generalized eigenvalue problem driver
            routine ZGGEV3.

            ZGGEV3 computes for a pair of n-by-n nonsymmetric matrices (A,B) the
            generalized eigenvalues and, optionally, the left and right
            eigenvectors.

            A generalized eigenvalue for a pair of matrices (A,B) is a scalar w
            or a ratio  alpha/beta = w, such that A - w*B is singular.  It is
            usually represented as the pair (alpha,beta), as there is reasonable
            interpretation for beta=0, and even for both being zero.

            A right generalized eigenvector corresponding to a generalized
            eigenvalue  w  for a pair of matrices (A,B) is a vector r  such that
            (A - wB) * r = 0.  A left generalized eigenvector is a vector l such
            that l**H * (A - wB) = 0, where l**H is the conjugate-transpose of l.

            When ZDRGEV3 is called, a number of matrix "sizes" ("n's") and a
            number of matrix "types" are specified.  For each size ("n")
            and each type of matrix, a pair of matrices (A, B) will be generated
            and used for testing.  For each matrix pair, the following tests
            will be performed and compared with the threshold THRESH.

            Results from ZGGEV3:

            (1)  max over all left eigenvalue/-vector pairs (alpha/beta,l) of

                 | VL**H * (beta A - alpha B) |/( ulp max(|beta A|, |alpha B|) )

                 where VL**H is the conjugate-transpose of VL.

            (2)  | |VL(i)| - 1 | / ulp and whether largest component real

                 VL(i) denotes the i-th column of VL.

            (3)  max over all left eigenvalue/-vector pairs (alpha/beta,r) of

                 | (beta A - alpha B) * VR | / ( ulp max(|beta A|, |alpha B|) )

            (4)  | |VR(i)| - 1 | / ulp and whether largest component real

                 VR(i) denotes the i-th column of VR.

            (5)  W(full) = W(partial)
                 W(full) denotes the eigenvalues computed when both l and r
                 are also computed, and W(partial) denotes the eigenvalues
                 computed when only W, only W and r, or only W and l are
                 computed.

            (6)  VL(full) = VL(partial)
                 VL(full) denotes the left eigenvectors computed when both l
                 and r are computed, and VL(partial) denotes the result
                 when only l is computed.

            (7)  VR(full) = VR(partial)
                 VR(full) denotes the right eigenvectors computed when both l
                 and r are also computed, and VR(partial) denotes the result
                 when only l is computed.

            Test Matrices
            ---- --------

            The sizes of the test matrices are specified by an array
            NN(1:NSIZES); the value of each element 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)  ( 0, 0 )         (a pair of zero matrices)

            (2)  ( I, 0 )         (an identity and a zero matrix)

            (3)  ( 0, I )         (an identity and a zero matrix)

            (4)  ( I, I )         (a pair of identity matrices)

                    t   t
            (5)  ( J , J  )       (a pair of transposed Jordan blocks)

                                                t                ( I   0  )
            (6)  ( X, Y )         where  X = ( J   0  )  and Y = (      t )
                                             ( 0   I  )          ( 0   J  )
                                  and I is a k x k identity and J a (k+1)x(k+1)
                                  Jordan block; k=(N-1)/2

            (7)  ( D, I )         where D is diag( 0, 1,..., N-1 ) (a diagonal
                                  matrix with those diagonal entries.)
            (8)  ( I, D )

            (9)  ( big*D, small*I ) where "big" is near overflow and small=1/big

            (10) ( small*D, big*I )

            (11) ( big*I, small*D )

            (12) ( small*I, big*D )

            (13) ( big*D, big*I )

            (14) ( small*D, small*I )

            (15) ( D1, D2 )        where D1 is diag( 0, 0, 1, ..., N-3, 0 ) and
                                   D2 is diag( 0, N-3, N-4,..., 1, 0, 0 )
                      t   t
            (16) Q ( J , J ) Z     where Q and Z are random orthogonal matrices.

            (17) Q ( T1, T2 ) Z    where T1 and T2 are upper triangular matrices
                                   with random O(1) entries above the diagonal
                                   and diagonal entries diag(T1) =
                                   ( 0, 0, 1, ..., N-3, 0 ) and diag(T2) =
                                   ( 0, N-3, N-4,..., 1, 0, 0 )

            (18) Q ( T1, T2 ) Z    diag(T1) = ( 0, 0, 1, 1, s, ..., s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1,..., 1, 0 )
                                   s = machine precision.

            (19) Q ( T1, T2 ) Z    diag(T1)=( 0,0,1,1, 1-d, ..., 1-(N-5)*d=s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0 )

                                                                   N-5
            (20) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, 1, a, ..., a   =s, 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )

            (21) Q ( T1, T2 ) Z    diag(T1)=( 0, 0, 1, r1, r2, ..., r(N-4), 0 )
                                   diag(T2) = ( 0, 1, 0, 1, ..., 1, 0, 0 )
                                   where r1,..., r(N-4) are random.

            (22) Q ( big*T1, small*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (23) Q ( small*T1, big*T2 ) Z    diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (24) Q ( small*T1, small*T2 ) Z  diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (25) Q ( big*T1, big*T2 ) Z      diag(T1) = ( 0, 0, 1, ..., N-3, 0 )
                                             diag(T2) = ( 0, 1, ..., 1, 0, 0 )

            (26) Q ( T1, T2 ) Z     where T1 and T2 are random upper-triangular
                                    matrices.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZDRGEV3 does nothing.  NSIZES >= 0.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  NN >= 0.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZDRGEV3
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZDRGES to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IERR not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original A matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, B, S, and T.
                     It must be at least 1 and at least max( NN ).

           B

                     B is COMPLEX*16 array, dimension(LDA, max(NN))
                     Used to hold the original B matrix.  Used as input only
                     if NTYPES=MAXTYP+1, DOTYPE(1:MAXTYP)=.FALSE., and
                     DOTYPE(MAXTYP+1)=.TRUE.

           S

                     S is COMPLEX*16 array, dimension (LDA, max(NN))
                     The Schur form matrix computed from A by ZGGEV3.  On exit, S
                     contains the Schur form matrix corresponding to the matrix
                     in A.

           T

                     T is COMPLEX*16 array, dimension (LDA, max(NN))
                     The upper triangular matrix computed from B by ZGGEV3.

           Q

                     Q is COMPLEX*16 array, dimension (LDQ, max(NN))
                     The (left) eigenvectors matrix computed by ZGGEV3.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of Q and Z. It must
                     be at least 1 and at least max( NN ).

           Z

                     Z is COMPLEX*16 array, dimension( LDQ, max(NN) )
                     The (right) orthogonal matrix computed by ZGGEV3.

           QE

                     QE is COMPLEX*16 array, dimension( LDQ, max(NN) )
                     QE holds the computed right or left eigenvectors.

           LDQE

                     LDQE is INTEGER
                     The leading dimension of QE. LDQE >= max(1,max(NN)).

           ALPHA

                     ALPHA is COMPLEX*16 array, dimension (max(NN))

           BETA

                     BETA is COMPLEX*16 array, dimension (max(NN))

                     The generalized eigenvalues of (A,B) computed by ZGGEV3.
                     ( ALPHAR(k)+ALPHAI(k)*i ) / BETA(k) is the k-th
                     generalized eigenvalue of A and B.

           ALPHA1

                     ALPHA1 is COMPLEX*16 array, dimension (max(NN))

           BETA1

                     BETA1 is COMPLEX*16 array, dimension (max(NN))

                     Like ALPHAR, ALPHAI, BETA, these arrays contain the
                     eigenvalues of A and B, but those computed when ZGGEV3 only
                     computes a partial eigendecomposition, i.e. not the
                     eigenvalues and left and right eigenvectors.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  LWORK >= N*(N+1)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (8*N)
                     Real workspace.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid overflow.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  A routine returned an error code.  INFO is the
                           absolute value of the INFO value returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           Febuary 2015

   subroutine zdrgsx (integer NSIZE, integer NCMAX, double precision THRESH, integer NIN, integer
       NOUT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
       complex*16, dimension( lda, * ) AI, complex*16, dimension( lda, * ) BI, complex*16,
       dimension( lda, * ) Z, complex*16, dimension( lda, * ) Q, complex*16, dimension( * )
       ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( ldc, * ) C, integer LDC,
       double precision, dimension( * ) S, complex*16, dimension( * ) WORK, integer LWORK, double
       precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer LIWORK, logical,
       dimension( * ) BWORK, integer INFO)
       ZDRGSX

       Purpose:

            ZDRGSX checks the nonsymmetric generalized eigenvalue (Schur form)
            problem expert driver ZGGESX.

            ZGGES factors A and B as Q*S*Z'  and Q*T*Z' , where ' means conjugate
            transpose, S and T are  upper triangular (i.e., in generalized Schur
            form), and Q and Z are unitary. It also computes the generalized
            eigenvalues (alpha(j),beta(j)), j=1,...,n.  Thus,
            w(j) = alpha(j)/beta(j) is a root of the characteristic equation

                            det( A - w(j) B ) = 0

            Optionally it also reorders the eigenvalues so that a selected
            cluster of eigenvalues appears in the leading diagonal block of the
            Schur forms; computes a reciprocal condition number for the average
            of the selected eigenvalues; and computes a reciprocal condition
            number for the right and left deflating subspaces corresponding to
            the selected eigenvalues.

            When ZDRGSX is called with NSIZE > 0, five (5) types of built-in
            matrix pairs are used to test the routine ZGGESX.

            When ZDRGSX is called with NSIZE = 0, it reads in test matrix data
            to test ZGGESX.
            (need more details on what kind of read-in data are needed).

            For each matrix pair, the following tests will be performed and
            compared with the threshold THRESH except for the tests (7) and (9):

            (1)   | A - Q S Z' | / ( |A| n ulp )

            (2)   | B - Q T Z' | / ( |B| n ulp )

            (3)   | I - QQ' | / ( n ulp )

            (4)   | I - ZZ' | / ( n ulp )

            (5)   if A is in Schur form (i.e. triangular form)

            (6)   maximum over j of D(j)  where:

                                |alpha(j) - S(j,j)|        |beta(j) - T(j,j)|
                      D(j) = ------------------------ + -----------------------
                             max(|alpha(j)|,|S(j,j)|)   max(|beta(j)|,|T(j,j)|)

            (7)   if sorting worked and SDIM is the number of eigenvalues
                  which were selected.

            (8)   the estimated value DIF does not differ from the true values of
                  Difu and Difl more than a factor 10*THRESH. If the estimate DIF
                  equals zero the corresponding true values of Difu and Difl
                  should be less than EPS*norm(A, B). If the true value of Difu
                  and Difl equal zero, the estimate DIF should be less than
                  EPS*norm(A, B).

            (9)   If INFO = N+3 is returned by ZGGESX, the reordering "failed"
                  and we check that DIF = PL = PR = 0 and that the true value of
                  Difu and Difl is < EPS*norm(A, B). We count the events when
                  INFO=N+3.

            For read-in test matrices, the same tests are run except that the
            exact value for DIF (and PL) is input data.  Additionally, there is
            one more test run for read-in test matrices:

            (10)  the estimated value PL does not differ from the true value of
                  PLTRU more than a factor THRESH. If the estimate PL equals
                  zero the corresponding true value of PLTRU should be less than
                  EPS*norm(A, B). If the true value of PLTRU equal zero, the
                  estimate PL should be less than EPS*norm(A, B).

            Note that for the built-in tests, a total of 10*NSIZE*(NSIZE-1)
            matrix pairs are generated and tested. NSIZE should be kept small.

            SVD (routine ZGESVD) is used for computing the true value of DIF_u
            and DIF_l when testing the built-in test problems.

            Built-in Test Matrices
            ======================

            All built-in test matrices are the 2 by 2 block of triangular
            matrices

                     A = [ A11 A12 ]    and      B = [ B11 B12 ]
                         [     A22 ]                 [     B22 ]

            where for different type of A11 and A22 are given as the following.
            A12 and B12 are chosen so that the generalized Sylvester equation

                     A11*R - L*A22 = -A12
                     B11*R - L*B22 = -B12

            have prescribed solution R and L.

            Type 1:  A11 = J_m(1,-1) and A_22 = J_k(1-a,1).
                     B11 = I_m, B22 = I_k
                     where J_k(a,b) is the k-by-k Jordan block with ``a'' on
                     diagonal and ``b'' on superdiagonal.

            Type 2:  A11 = (a_ij) = ( 2(.5-sin(i)) ) and
                     B11 = (b_ij) = ( 2(.5-sin(ij)) ) for i=1,...,m, j=i,...,m
                     A22 = (a_ij) = ( 2(.5-sin(i+j)) ) and
                     B22 = (b_ij) = ( 2(.5-sin(ij)) ) for i=m+1,...,k, j=i,...,k

            Type 3:  A11, A22 and B11, B22 are chosen as for Type 2, but each
                     second diagonal block in A_11 and each third diagonal block
                     in A_22 are made as 2 by 2 blocks.

            Type 4:  A11 = ( 20(.5 - sin(ij)) ) and B22 = ( 2(.5 - sin(i+j)) )
                        for i=1,...,m,  j=1,...,m and
                     A22 = ( 20(.5 - sin(i+j)) ) and B22 = ( 2(.5 - sin(ij)) )
                        for i=m+1,...,k,  j=m+1,...,k

            Type 5:  (A,B) and have potentially close or common eigenvalues and
                     very large departure from block diagonality A_11 is chosen
                     as the m x m leading submatrix of A_1:
                             |  1  b                            |
                             | -b  1                            |
                             |        1+d  b                    |
                             |         -b 1+d                   |
                      A_1 =  |                  d  1            |
                             |                 -1  d            |
                             |                        -d  1     |
                             |                        -1 -d     |
                             |                               1  |
                     and A_22 is chosen as the k x k leading submatrix of A_2:
                             | -1  b                            |
                             | -b -1                            |
                             |       1-d  b                     |
                             |       -b  1-d                    |
                      A_2 =  |                 d 1+b            |
                             |               -1-b d             |
                             |                       -d  1+b    |
                             |                      -1+b  -d    |
                             |                              1-d |
                     and matrix B are chosen as identity matrices (see DLATM5).

       Parameters:
           NSIZE

                     NSIZE is INTEGER
                     The maximum size of the matrices to use. NSIZE >= 0.
                     If NSIZE = 0, no built-in tests matrices are used, but
                     read-in test matrices are used to test DGGESX.

           NCMAX

                     NCMAX is INTEGER
                     Maximum allowable NMAX for generating Kroneker matrix
                     in call to ZLAKF2

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.  THRESH >= 0.

           NIN

                     NIN is INTEGER
                     The FORTRAN unit number for reading in the data file of
                     problems to solve.

           NOUT

                     NOUT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns INFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Used to store the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually used.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, B, AI, BI, Z and Q,
                     LDA >= max( 1, NSIZE ). For the read-in test,
                     LDA >= max( 1, N ), N is the size of the test matrices.

           B

                     B is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Used to store the matrix whose eigenvalues are to be
                     computed.  On exit, B contains the last matrix actually used.

           AI

                     AI is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Copy of A, modified by ZGGESX.

           BI

                     BI is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Copy of B, modified by ZGGESX.

           Z

                     Z is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Z holds the left Schur vectors computed by ZGGESX.

           Q

                     Q is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Q holds the right Schur vectors computed by ZGGESX.

           ALPHA

                     ALPHA is COMPLEX*16 array, dimension (NSIZE)

           BETA

                     BETA is COMPLEX*16 array, dimension (NSIZE)

                     On exit, ALPHA/BETA are the eigenvalues.

           C

                     C is COMPLEX*16 array, dimension (LDC, LDC)
                     Store the matrix generated by subroutine ZLAKF2, this is the
                     matrix formed by Kronecker products used for estimating
                     DIF.

           LDC

                     LDC is INTEGER
                     The leading dimension of C. LDC >= max(1, LDA*LDA/2 ).

           S

                     S is DOUBLE PRECISION array, dimension (LDC)
                     Singular values of C

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.  LWORK >= 3*NSIZE*NSIZE/2

           RWORK

                     RWORK is DOUBLE PRECISION array,
                                            dimension (5*NSIZE*NSIZE/2 - 4)

           IWORK

                     IWORK is INTEGER array, dimension (LIWORK)

           LIWORK

                     LIWORK is INTEGER
                     The dimension of the array IWORK. LIWORK >= NSIZE + 2.

           BWORK

                     BWORK is LOGICAL array, dimension (NSIZE)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  A routine returned an error code.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrgvx (integer NSIZE, double precision THRESH, integer NIN, integer NOUT,
       complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) B,
       complex*16, dimension( lda, * ) AI, complex*16, dimension( lda, * ) BI, complex*16,
       dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16, dimension( lda, * ) VL,
       complex*16, dimension( lda, * ) VR, integer ILO, integer IHI, double precision, dimension(
       * ) LSCALE, double precision, dimension( * ) RSCALE, double precision, dimension( * ) S,
       double precision, dimension( * ) DTRU, double precision, dimension( * ) DIF, double
       precision, dimension( * ) DIFTRU, complex*16, dimension( * ) WORK, integer LWORK, double
       precision, dimension( * ) RWORK, integer, dimension( * ) IWORK, integer LIWORK, double
       precision, dimension( 4 ) RESULT, logical, dimension( * ) BWORK, integer INFO)
       ZDRGVX

       Purpose:

            ZDRGVX checks the nonsymmetric generalized eigenvalue problem
            expert driver ZGGEVX.

            ZGGEVX computes the generalized eigenvalues, (optionally) the left
            and/or right eigenvectors, (optionally) computes a balancing
            transformation to improve the conditioning, and (optionally)
            reciprocal condition numbers for the eigenvalues and eigenvectors.

            When ZDRGVX is called with NSIZE > 0, two types of test matrix pairs
            are generated by the subroutine DLATM6 and test the driver ZGGEVX.
            The test matrices have the known exact condition numbers for
            eigenvalues. For the condition numbers of the eigenvectors
            corresponding the first and last eigenvalues are also know
            ``exactly'' (see ZLATM6).
            For each matrix pair, the following tests will be performed and
            compared with the threshold THRESH.

            (1) max over all left eigenvalue/-vector pairs (beta/alpha,l) of

               | l**H * (beta A - alpha B) | / ( ulp max( |beta A|, |alpha B| ) )

                where l**H is the conjugate tranpose of l.

            (2) max over all right eigenvalue/-vector pairs (beta/alpha,r) of

                  | (beta A - alpha B) r | / ( ulp max( |beta A|, |alpha B| ) )

            (3) The condition number S(i) of eigenvalues computed by ZGGEVX
                differs less than a factor THRESH from the exact S(i) (see
                ZLATM6).

            (4) DIF(i) computed by ZTGSNA differs less than a factor 10*THRESH
                from the exact value (for the 1st and 5th vectors only).

            Test Matrices
            =============

            Two kinds of test matrix pairs
                     (A, B) = inverse(YH) * (Da, Db) * inverse(X)
            are used in the tests:

            1: Da = 1+a   0    0    0    0    Db = 1   0   0   0   0
                     0   2+a   0    0    0         0   1   0   0   0
                     0    0   3+a   0    0         0   0   1   0   0
                     0    0    0   4+a   0         0   0   0   1   0
                     0    0    0    0   5+a ,      0   0   0   0   1 , and

            2: Da =  1   -1    0    0    0    Db = 1   0   0   0   0
                     1    1    0    0    0         0   1   0   0   0
                     0    0    1    0    0         0   0   1   0   0
                     0    0    0   1+a  1+b        0   0   0   1   0
                     0    0    0  -1-b  1+a ,      0   0   0   0   1 .

            In both cases the same inverse(YH) and inverse(X) are used to compute
            (A, B), giving the exact eigenvectors to (A,B) as (YH, X):

            YH:  =  1    0   -y    y   -y    X =  1   0  -x  -x   x
                    0    1   -y    y   -y         0   1   x  -x  -x
                    0    0    1    0    0         0   0   1   0   0
                    0    0    0    1    0         0   0   0   1   0
                    0    0    0    0    1,        0   0   0   0   1 , where

            a, b, x and y will have all values independently of each other from
            { sqrt(sqrt(ULP)),  0.1,  1,  10,  1/sqrt(sqrt(ULP)) }.

       Parameters:
           NSIZE

                     NSIZE is INTEGER
                     The number of sizes of matrices to use.  NSIZE must be at
                     least zero. If it is zero, no randomly generated matrices
                     are tested, but any test matrices read from NIN will be
                     tested.  If it is not zero, then N = 5.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NIN

                     NIN is INTEGER
                     The FORTRAN unit number for reading in the data file of
                     problems to solve.

           NOUT

                     NOUT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually used.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, B, AI, BI, Ao, and Bo.
                     It must be at least 1 and at least NSIZE.

           B

                     B is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, B contains the last matrix actually used.

           AI

                     AI is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Copy of A, modified by ZGGEVX.

           BI

                     BI is COMPLEX*16 array, dimension (LDA, NSIZE)
                     Copy of B, modified by ZGGEVX.

           ALPHA

                     ALPHA is COMPLEX*16 array, dimension (NSIZE)

           BETA

                     BETA is COMPLEX*16 array, dimension (NSIZE)

                     On exit, ALPHA/BETA are the eigenvalues.

           VL

                     VL is COMPLEX*16 array, dimension (LDA, NSIZE)
                     VL holds the left eigenvectors computed by ZGGEVX.

           VR

                     VR is COMPLEX*16 array, dimension (LDA, NSIZE)
                     VR holds the right eigenvectors computed by ZGGEVX.

           ILO

                           ILO is INTEGER

           IHI

                           IHI is INTEGER

           LSCALE

                           LSCALE is DOUBLE PRECISION array, dimension (N)

           RSCALE

                           RSCALE is DOUBLE PRECISION array, dimension (N)

           S

                           S is DOUBLE PRECISION array, dimension (N)

           DTRU

                           DTRU is DOUBLE PRECISION array, dimension (N)

           DIF

                           DIF is DOUBLE PRECISION array, dimension (N)

           DIFTRU

                           DIFTRU is DOUBLE PRECISION array, dimension (N)

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     Leading dimension of WORK.  LWORK >= 2*N*N + 2*N

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (6*N)

           IWORK

                     IWORK is INTEGER array, dimension (LIWORK)

           LIWORK

                     LIWORK is INTEGER
                     Leading dimension of IWORK.  LIWORK >= N+2.

           RESULT

                           RESULT is DOUBLE PRECISION array, dimension (4)

           BWORK

                     BWORK is LOGICAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value.
                     > 0:  A routine returned an error code.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   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)
       ZDRVBD

       Purpose:

            ZDRVBD checks the singular value decomposition (SVD) driver ZGESVD
            and ZGESDD.
            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 "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 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:

            (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 ZGESVJ:

            (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 ZGEJSV:

            (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 ZGESVDX( 'V', 'V', 'A' )/ZGESVDX( '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 ZGESVDX( '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 ZGESVDX( '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.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZDRVBD does nothing.  It must be at least zero.

           MM

                     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.

           NN

                     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.

           NTYPES

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

           DOTYPE

                     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.

           ISEED

                     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.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           A

                     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.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at
                     least 1 and at least max( MM ).

           U

                     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.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  It must be at
                     least 1 and at least max( MM ).

           VT

                     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.

           LDVT

                     LDVT is INTEGER
                     The leading dimension of VT.  It must be at
                     least 1 and at least max( NN ).

           ASAV

                     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.

           USAV

                     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.

           VTSAV

                     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.

           S

                     S is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
                     Contains the computed singular values.

           SSAV

                     SSAV is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
                     Contains another copy of the computed singular values.

           E

                     E is DOUBLE PRECISION array, dimension (max(min(MM,NN)))
                     Workspace for ZGESVD.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     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))

           RWORK

                     RWORK is DOUBLE PRECISION array,
                                 dimension ( 5*max(max(MM,NN)) )

           IWORK

                     IWORK is INTEGER array, dimension at least 8*min(M,N)

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)

           INFO

                     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.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zdrves (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H,
       complex*16, dimension( lda, * ) HT, complex*16, dimension( * ) W, complex*16, dimension( *
       ) WT, complex*16, dimension( ldvs, * ) VS, integer LDVS, double precision, dimension( 13 )
       RESULT, complex*16, dimension( * ) WORK, integer NWORK, double precision, dimension( * )
       RWORK, integer, dimension( * ) IWORK, logical, dimension( * ) BWORK, integer INFO)
       ZDRVES

       Purpose:

               ZDRVES checks the nonsymmetric eigenvalue (Schur form) problem
               driver ZGEES.

               When ZDRVES is called, a number of matrix "sizes" ("n's") and a
               number of matrix "types" are specified.  For each size ("n")
               and each type of matrix, one matrix will be generated and used
               to test the nonsymmetric eigenroutines.  For each matrix, 13
               tests will be performed:

               (1)     0 if T is in Schur form, 1/ulp otherwise
                      (no sorting of eigenvalues)

               (2)     | A - VS T VS' | / ( n |A| ulp )

                 Here VS is the matrix of Schur eigenvectors, and T is in Schur
                 form  (no sorting of eigenvalues).

               (3)     | I - VS VS' | / ( n ulp ) (no sorting of eigenvalues).

               (4)     0     if W are eigenvalues of T
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (5)     0     if T(with VS) = T(without VS),
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (6)     0     if eigenvalues(with VS) = eigenvalues(without VS),
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (7)     0 if T is in Schur form, 1/ulp otherwise
                       (with sorting of eigenvalues)

               (8)     | A - VS T VS' | / ( n |A| ulp )

                 Here VS is the matrix of Schur eigenvectors, and T is in Schur
                 form  (with sorting of eigenvalues).

               (9)     | I - VS VS' | / ( n ulp ) (with sorting of eigenvalues).

               (10)    0     if W are eigenvalues of T
                       1/ulp otherwise
                       (with sorting of eigenvalues)

               (11)    0     if T(with VS) = T(without VS),
                       1/ulp otherwise
                       (with sorting of eigenvalues)

               (12)    0     if eigenvalues(with VS) = eigenvalues(without VS),
                       1/ulp otherwise
                       (with sorting of eigenvalues)

               (13)    if sorting worked and SDIM is the number of
                       eigenvalues which were SELECTed

               The "sizes" are specified by an array NN(1:NSIZES); the value of
               each element 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 (transposed) Jordan block, with 1's on the diagonal.

               (4)  A diagonal matrix with evenly spaced entries
                    1, ..., ULP  and random complex angles.
                    (ULP = (first number larger than 1) - 1 )
               (5)  A diagonal matrix with geometrically spaced entries
                    1, ..., ULP  and random complex angles.
               (6)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                    and random complex angles.

               (7)  Same as (4), but multiplied by a constant near
                    the overflow threshold
               (8)  Same as (4), but multiplied by a constant near
                    the underflow threshold

               (9)  A matrix of the form  U' T U, where U is unitary and
                    T has evenly spaced entries 1, ..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (10) A matrix of the form  U' T U, where U is unitary and
                    T has geometrically spaced entries 1, ..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (11) A matrix of the form  U' T U, where U is orthogonal and
                    T has "clustered" entries 1, ULP,..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (12) A matrix of the form  U' T U, where U is unitary and
                    T has complex eigenvalues randomly chosen from
                    ULP < |z| < 1   and random O(1) entries in the upper
                    triangle.

               (13) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (14) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has geometrically spaced entries
                    1, ..., ULP with random complex angles on the diagonal
                    and random O(1) entries in the upper triangle.

               (15) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (16) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has complex eigenvalues randomly chosen
                    from ULP < |z| < 1 and random O(1) entries in the upper
                    triangle.

               (17) Same as (16), but multiplied by a constant
                    near the overflow threshold
               (18) Same as (16), but multiplied by a constant
                    near the underflow threshold

               (19) Nonsymmetric matrix with random entries chosen from (-1,1).
                    If N is at least 4, all entries in first two rows and last
                    row, and first column and last two columns are zero.
               (20) Same as (19), but multiplied by a constant
                    near the overflow threshold
               (21) Same as (19), but multiplied by a constant
                    near the underflow threshold

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZDRVES does nothing.  It must be at least zero.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZDRVES
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZDRVES to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns INFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension (LDA, max(NN))
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually used.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, and H. LDA must be at
                     least 1 and at least max( NN ).

           H

                     H is COMPLEX*16 array, dimension (LDA, max(NN))
                     Another copy of the test matrix A, modified by ZGEES.

           HT

                     HT is COMPLEX*16 array, dimension (LDA, max(NN))
                     Yet another copy of the test matrix A, modified by ZGEES.

           W

                     W is COMPLEX*16 array, dimension (max(NN))
                     The computed eigenvalues of A.

           WT

                     WT is COMPLEX*16 array, dimension (max(NN))
                     Like W, this array contains the eigenvalues of A,
                     but those computed when ZGEES only computes a partial
                     eigendecomposition, i.e. not Schur vectors

           VS

                     VS is COMPLEX*16 array, dimension (LDVS, max(NN))
                     VS holds the computed Schur vectors.

           LDVS

                     LDVS is INTEGER
                     Leading dimension of VS. Must be at least max(1,max(NN)).

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (13)
                     The values computed by the 13 tests described above.
                     The values are currently limited to 1/ulp, to avoid overflow.

           WORK

                     WORK is COMPLEX*16 array, dimension (NWORK)

           NWORK

                     NWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     5*NN(j)+2*NN(j)**2 for all j.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(NN))

           IWORK

                     IWORK is INTEGER array, dimension (max(NN))

           BWORK

                     BWORK is LOGICAL array, dimension (max(NN))

           INFO

                     INFO is INTEGER
                     If 0, then everything ran OK.
                      -1: NSIZES < 0
                      -2: Some NN(j) < 0
                      -3: NTYPES < 0
                      -6: THRESH < 0
                      -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
                     -15: LDVS < 1 or LDVS < NMAX, where NMAX is max( NN(j) ).
                     -18: NWORK too small.
                     If  ZLATMR, CLATMS, CLATME or ZGEES returns an error code,
                         the absolute value of it is returned.

           -----------------------------------------------------------------------

                Some Local Variables and Parameters:
                ---- ----- --------- --- ----------
                ZERO, ONE       Real 0 and 1.
                MAXTYP          The number of types defined.
                NMAX            Largest value in NN.
                NERRS           The number of tests which have exceeded THRESH
                COND, CONDS,
                IMODE           Values to be passed to the matrix generators.
                ANORM           Norm of A; passed to matrix generators.

                OVFL, UNFL      Overflow and underflow thresholds.
                ULP, ULPINV     Finest relative precision and its inverse.
                RTULP, RTULPI   Square roots of the previous 4 values.
                        The following four arrays decode JTYPE:
                KTYPE(j)        The general type (1-10) for type "j".
                KMODE(j)        The MODE value to be passed to the matrix
                                generator for type "j".
                KMAGN(j)        The order of magnitude ( O(1),
                                O(overflow^(1/2) ), O(underflow^(1/2) )
                KCONDS(j)       Select whether CONDS is to be 1 or
                                1/sqrt(ulp).  (0 means irrelevant.)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvev (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H,
       complex*16, dimension( * ) W, complex*16, dimension( * ) W1, complex*16, dimension( ldvl,
       * ) VL, integer LDVL, complex*16, dimension( ldvr, * ) VR, integer LDVR, complex*16,
       dimension( ldlre, * ) LRE, integer LDLRE, double precision, dimension( 7 ) RESULT,
       complex*16, dimension( * ) WORK, integer NWORK, double precision, dimension( * ) RWORK,
       integer, dimension( * ) IWORK, integer INFO)
       ZDRVEV

       Purpose:

               ZDRVEV  checks the nonsymmetric eigenvalue problem driver ZGEEV.

               When ZDRVEV is called, a number of matrix "sizes" ("n's") and a
               number of matrix "types" are specified.  For each size ("n")
               and each type of matrix, one matrix will be generated and used
               to test the nonsymmetric eigenroutines.  For each matrix, 7
               tests will be performed:

               (1)     | A * VR - VR * W | / ( n |A| ulp )

                 Here VR is the matrix of unit right eigenvectors.
                 W is a diagonal matrix with diagonal entries W(j).

               (2)     | A**H * VL - VL * W**H | / ( n |A| ulp )

                 Here VL is the matrix of unit left eigenvectors, A**H is the
                 conjugate-transpose of A, and W is as above.

               (3)     | |VR(i)| - 1 | / ulp and whether largest component real

                 VR(i) denotes the i-th column of VR.

               (4)     | |VL(i)| - 1 | / ulp and whether largest component real

                 VL(i) denotes the i-th column of VL.

               (5)     W(full) = W(partial)

                 W(full) denotes the eigenvalues computed when both VR and VL
                 are also computed, and W(partial) denotes the eigenvalues
                 computed when only W, only W and VR, or only W and VL are
                 computed.

               (6)     VR(full) = VR(partial)

                 VR(full) denotes the right eigenvectors computed when both VR
                 and VL are computed, and VR(partial) denotes the result
                 when only VR is computed.

                (7)     VL(full) = VL(partial)

                 VL(full) denotes the left eigenvectors computed when both VR
                 and VL are also computed, and VL(partial) denotes the result
                 when only VL is computed.

               The "sizes" are specified by an array NN(1:NSIZES); the value of
               each element 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 (transposed) Jordan block, with 1's on the diagonal.

               (4)  A diagonal matrix with evenly spaced entries
                    1, ..., ULP  and random complex angles.
                    (ULP = (first number larger than 1) - 1 )
               (5)  A diagonal matrix with geometrically spaced entries
                    1, ..., ULP  and random complex angles.
               (6)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                    and random complex angles.

               (7)  Same as (4), but multiplied by a constant near
                    the overflow threshold
               (8)  Same as (4), but multiplied by a constant near
                    the underflow threshold

               (9)  A matrix of the form  U' T U, where U is unitary and
                    T has evenly spaced entries 1, ..., ULP with random complex
                    angles on the diagonal and random O(1) entries in the upper
                    triangle.

               (10) A matrix of the form  U' T U, where U is unitary and
                    T has geometrically spaced entries 1, ..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (11) A matrix of the form  U' T U, where U is unitary and
                    T has "clustered" entries 1, ULP,..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (12) A matrix of the form  U' T U, where U is unitary and
                    T has complex eigenvalues randomly chosen from
                    ULP < |z| < 1   and random O(1) entries in the upper
                    triangle.

               (13) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (14) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has geometrically spaced entries
                    1, ..., ULP with random complex angles on the diagonal
                    and random O(1) entries in the upper triangle.

               (15) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (16) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has complex eigenvalues randomly chosen
                    from ULP < |z| < 1 and random O(1) entries in the upper
                    triangle.

               (17) Same as (16), but multiplied by a constant
                    near the overflow threshold
               (18) Same as (16), but multiplied by a constant
                    near the underflow threshold

               (19) Nonsymmetric matrix with random entries chosen from |z| < 1
                    If N is at least 4, all entries in first two rows and last
                    row, and first column and last two columns are zero.
               (20) Same as (19), but multiplied by a constant
                    near the overflow threshold
               (21) Same as (19), but multiplied by a constant
                    near the underflow threshold

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZDRVEV does nothing.  It must be at least zero.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZDRVEV
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZDRVEV to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns INFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension (LDA, max(NN))
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually used.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, and H. LDA must be at
                     least 1 and at least max(NN).

           H

                     H is COMPLEX*16 array, dimension (LDA, max(NN))
                     Another copy of the test matrix A, modified by ZGEEV.

           W

                     W is COMPLEX*16 array, dimension (max(NN))
                     The eigenvalues of A. On exit, W are the eigenvalues of
                     the matrix in A.

           W1

                     W1 is COMPLEX*16 array, dimension (max(NN))
                     Like W, this array contains the eigenvalues of A,
                     but those computed when ZGEEV only computes a partial
                     eigendecomposition, i.e. not the eigenvalues and left
                     and right eigenvectors.

           VL

                     VL is COMPLEX*16 array, dimension (LDVL, max(NN))
                     VL holds the computed left eigenvectors.

           LDVL

                     LDVL is INTEGER
                     Leading dimension of VL. Must be at least max(1,max(NN)).

           VR

                     VR is COMPLEX*16 array, dimension (LDVR, max(NN))
                     VR holds the computed right eigenvectors.

           LDVR

                     LDVR is INTEGER
                     Leading dimension of VR. Must be at least max(1,max(NN)).

           LRE

                     LRE is COMPLEX*16 array, dimension (LDLRE, max(NN))
                     LRE holds the computed right or left eigenvectors.

           LDLRE

                     LDLRE is INTEGER
                     Leading dimension of LRE. Must be at least max(1,max(NN)).

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (7)
                     The values computed by the seven tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           WORK

                     WORK is COMPLEX*16 array, dimension (NWORK)

           NWORK

                     NWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     5*NN(j)+2*NN(j)**2 for all j.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*max(NN))

           IWORK

                     IWORK is INTEGER array, dimension (max(NN))

           INFO

                     INFO is INTEGER
                     If 0, then everything ran OK.
                      -1: NSIZES < 0
                      -2: Some NN(j) < 0
                      -3: NTYPES < 0
                      -6: THRESH < 0
                      -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
                     -14: LDVL < 1 or LDVL < NMAX, where NMAX is max( NN(j) ).
                     -16: LDVR < 1 or LDVR < NMAX, where NMAX is max( NN(j) ).
                     -18: LDLRE < 1 or LDLRE < NMAX, where NMAX is max( NN(j) ).
                     -21: NWORK too small.
                     If  ZLATMR, CLATMS, CLATME or ZGEEV returns an error code,
                         the absolute value of it is returned.

           -----------------------------------------------------------------------

                Some Local Variables and Parameters:
                ---- ----- --------- --- ----------

                ZERO, ONE       Real 0 and 1.
                MAXTYP          The number of types defined.
                NMAX            Largest value in NN.
                NERRS           The number of tests which have exceeded THRESH
                COND, CONDS,
                IMODE           Values to be passed to the matrix generators.
                ANORM           Norm of A; passed to matrix generators.

                OVFL, UNFL      Overflow and underflow thresholds.
                ULP, ULPINV     Finest relative precision and its inverse.
                RTULP, RTULPI   Square roots of the previous 4 values.

                        The following four arrays decode JTYPE:
                KTYPE(j)        The general type (1-10) for type "j".
                KMODE(j)        The MODE value to be passed to the matrix
                                generator for type "j".
                KMAGN(j)        The order of magnitude ( O(1),
                                O(overflow^(1/2) ), O(underflow^(1/2) )
                KCONDS(j)       Selectw whether CONDS is to be 1 or
                                1/sqrt(ulp).  (0 means irrelevant.)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvsg (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B,
       integer LDB, double precision, dimension( * ) D, complex*16, dimension( ldz, * ) Z,
       integer LDZ, complex*16, dimension( lda, * ) AB, complex*16, dimension( ldb, * ) BB,
       complex*16, dimension( * ) AP, complex*16, dimension( * ) BP, complex*16, dimension( * )
       WORK, integer NWORK, double precision, dimension( * ) RWORK, integer LRWORK, integer,
       dimension( * ) IWORK, integer LIWORK, double precision, dimension( * ) RESULT, integer
       INFO)
       ZDRVSG

       Purpose:

                 ZDRVSG checks the complex Hermitian generalized eigenproblem
                 drivers.

                         ZHEGV computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite generalized
                         eigenproblem.

                         ZHEGVD computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite generalized
                         eigenproblem using a divide and conquer algorithm.

                         ZHEGVX computes selected eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite generalized
                         eigenproblem.

                         ZHPGV computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite generalized
                         eigenproblem in packed storage.

                         ZHPGVD computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite generalized
                         eigenproblem in packed storage using a divide and
                         conquer algorithm.

                         ZHPGVX computes selected eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite generalized
                         eigenproblem in packed storage.

                         ZHBGV computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite banded
                         generalized eigenproblem.

                         ZHBGVD computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite banded
                         generalized eigenproblem using a divide and conquer
                         algorithm.

                         ZHBGVX computes selected eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian-definite banded
                         generalized eigenproblem.

                 When ZDRVSG is called, a number of matrix "sizes" ("n's") and a
                 number of matrix "types" are specified.  For each size ("n")
                 and each type of matrix, one matrix A of the given type will be
                 generated; a random well-conditioned matrix B is also generated
                 and the pair (A,B) is used to test the drivers.

                 For each pair (A,B), the following tests are performed:

                 (1) ZHEGV with ITYPE = 1 and UPLO ='U':

                         | A Z - B Z D | / ( |A| |Z| n ulp )

                 (2) as (1) but calling ZHPGV
                 (3) as (1) but calling ZHBGV
                 (4) as (1) but with UPLO = 'L'
                 (5) as (4) but calling ZHPGV
                 (6) as (4) but calling ZHBGV

                 (7) ZHEGV with ITYPE = 2 and UPLO ='U':

                         | A B Z - Z D | / ( |A| |Z| n ulp )

                 (8) as (7) but calling ZHPGV
                 (9) as (7) but with UPLO = 'L'
                 (10) as (9) but calling ZHPGV

                 (11) ZHEGV with ITYPE = 3 and UPLO ='U':

                         | B A Z - Z D | / ( |A| |Z| n ulp )

                 (12) as (11) but calling ZHPGV
                 (13) as (11) but with UPLO = 'L'
                 (14) as (13) but calling ZHPGV

                 ZHEGVD, ZHPGVD and ZHBGVD performed the same 14 tests.

                 ZHEGVX, ZHPGVX and ZHBGVX performed the above 14 tests with
                 the parameter RANGE = 'A', 'N' and 'I', respectively.

                 The "sizes" are specified by an array NN(1:NSIZES); the value of
                 each element 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.
                 This type is used for the matrix A which has half-bandwidth KA.
                 B is generated as a well-conditioned positive definite matrix
                 with half-bandwidth KB (<= KA).
                 Currently, the list of possible types for A is:

                 (1)  The zero matrix.
                 (2)  The identity matrix.

                 (3)  A diagonal matrix with evenly spaced entries
                      1, ..., ULP  and random signs.
                      (ULP = (first number larger than 1) - 1 )
                 (4)  A diagonal matrix with geometrically spaced entries
                      1, ..., ULP  and random signs.
                 (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                      and random signs.

                 (6)  Same as (4), but multiplied by SQRT( overflow threshold )
                 (7)  Same as (4), but multiplied by SQRT( underflow threshold )

                 (8)  A matrix of the form  U* D U, where U is unitary and
                      D has evenly spaced entries 1, ..., ULP with random signs
                      on the diagonal.

                 (9)  A matrix of the form  U* D U, where U is unitary and
                      D has geometrically spaced entries 1, ..., ULP with random
                      signs on the diagonal.

                 (10) A matrix of the form  U* D U, where U is unitary and
                      D has "clustered" entries 1, ULP,..., ULP with random
                      signs on the diagonal.

                 (11) Same as (8), but multiplied by SQRT( overflow threshold )
                 (12) Same as (8), but multiplied by SQRT( underflow threshold )

                 (13) Hermitian matrix with random entries chosen from (-1,1).
                 (14) Same as (13), but multiplied by SQRT( overflow threshold )
                 (15) Same as (13), but multiplied by SQRT( underflow threshold )

                 (16) Same as (8), but with KA = 1 and KB = 1
                 (17) Same as (8), but with KA = 2 and KB = 1
                 (18) Same as (8), but with KA = 2 and KB = 2
                 (19) Same as (8), but with KA = 3 and KB = 1
                 (20) Same as (8), but with KA = 3 and KB = 2
                 (21) Same as (8), but with KA = 3 and KB = 3

             NSIZES  INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZDRVSG does nothing.  It must be at least zero.
                     Not modified.

             NN      INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.
                     Not modified.

             NTYPES  INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZDRVSG
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .
                     Not modified.

             DOTYPE  LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.
                     Not modified.

             ISEED   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 ZDRVSG to continue the same random number
                     sequence.
                     Modified.

             THRESH  DOUBLE PRECISION
                     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.
                     Not modified.

             NOUNIT  INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)
                     Not modified.

             A       COMPLEX*16 array, dimension (LDA , max(NN))
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually
                     used.
                     Modified.

             LDA     INTEGER
                     The leading dimension of A.  It must be at
                     least 1 and at least max( NN ).
                     Not modified.

             B       COMPLEX*16 array, dimension (LDB , max(NN))
                     Used to hold the Hermitian positive definite matrix for
                     the generailzed problem.
                     On exit, B contains the last matrix actually
                     used.
                     Modified.

             LDB     INTEGER
                     The leading dimension of B.  It must be at
                     least 1 and at least max( NN ).
                     Not modified.

             D       DOUBLE PRECISION array, dimension (max(NN))
                     The eigenvalues of A. On exit, the eigenvalues in D
                     correspond with the matrix in A.
                     Modified.

             Z       COMPLEX*16 array, dimension (LDZ, max(NN))
                     The matrix of eigenvectors.
                     Modified.

             LDZ     INTEGER
                     The leading dimension of ZZ.  It must be at least 1 and
                     at least max( NN ).
                     Not modified.

             AB      COMPLEX*16 array, dimension (LDA, max(NN))
                     Workspace.
                     Modified.

             BB      COMPLEX*16 array, dimension (LDB, max(NN))
                     Workspace.
                     Modified.

             AP      COMPLEX*16 array, dimension (max(NN)**2)
                     Workspace.
                     Modified.

             BP      COMPLEX*16 array, dimension (max(NN)**2)
                     Workspace.
                     Modified.

             WORK    COMPLEX*16 array, dimension (NWORK)
                     Workspace.
                     Modified.

             NWORK   INTEGER
                     The number of entries in WORK.  This must be at least
                     2*N + N**2  where  N = max( NN(j), 2 ).
                     Not modified.

             RWORK   DOUBLE PRECISION array, dimension (LRWORK)
                     Workspace.
                     Modified.

             LRWORK  INTEGER
                     The number of entries in RWORK.  This must be at least
                     max( 7*N, 1 + 4*N + 2*N*lg(N) + 3*N**2 ) where
                     N = max( NN(j) ) and lg( N ) = smallest integer k such
                     that 2**k >= N .
                     Not modified.

             IWORK   INTEGER array, dimension (LIWORK))
                     Workspace.
                     Modified.

             LIWORK  INTEGER
                     The number of entries in IWORK.  This must be at least
                     2 + 5*max( NN(j) ).
                     Not modified.

             RESULT  DOUBLE PRECISION array, dimension (70)
                     The values computed by the 70 tests described above.
                     Modified.

             INFO    INTEGER
                     If 0, then everything ran OK.
                      -1: NSIZES < 0
                      -2: Some NN(j) < 0
                      -3: NTYPES < 0
                      -5: THRESH < 0
                      -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
                     -16: LDZ < 1 or LDZ < NMAX.
                     -21: NWORK too small.
                     -23: LRWORK too small.
                     -25: LIWORK too small.
                     If  ZLATMR, CLATMS, ZHEGV, ZHPGV, ZHBGV, CHEGVD, CHPGVD,
                         ZHPGVD, ZHEGVX, CHPGVX, ZHBGVX returns an error code,
                         the absolute value of it is returned.
                     Modified.

           -----------------------------------------------------------------------

                  Some Local Variables and Parameters:
                  ---- ----- --------- --- ----------
                  ZERO, ONE       Real 0 and 1.
                  MAXTYP          The number of types defined.
                  NTEST           The number of tests that have been run
                                  on this matrix.
                  NTESTT          The total number of tests for this call.
                  NMAX            Largest value in NN.
                  NMATS           The number of matrices generated so far.
                  NERRS           The number of tests which have exceeded THRESH
                                  so far (computed by DLAFTS).
                  COND, IMODE     Values to be passed to the matrix generators.
                  ANORM           Norm of A; passed to matrix generators.

                  OVFL, UNFL      Overflow and underflow thresholds.
                  ULP, ULPINV     Finest relative precision and its inverse.
                  RTOVFL, RTUNFL  Square roots of the previous 2 values.
                          The following four arrays decode JTYPE:
                  KTYPE(j)        The general type (1-10) for type "j".
                  KMODE(j)        The MODE value to be passed to the matrix
                                  generator for type "j".
                  KMAGN(j)        The order of magnitude ( O(1),
                                  O(overflow^(1/2) ), O(underflow^(1/2) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvst (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * )
       D1, double precision, dimension( * ) D2, double precision, dimension( * ) D3, double
       precision, dimension( * ) WA1, double precision, dimension( * ) WA2, double precision,
       dimension( * ) WA3, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension(
       ldu, * ) V, complex*16, dimension( * ) TAU, complex*16, dimension( ldu, * ) Z, complex*16,
       dimension( * ) WORK, integer LWORK, double precision, dimension( * ) RWORK, integer
       LRWORK, integer, dimension( * ) IWORK, integer LIWORK, double precision, dimension( * )
       RESULT, integer INFO)
       ZDRVST

       Purpose:

                 ZDRVST  checks the Hermitian eigenvalue problem drivers.

                         ZHEEVD computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian matrix,
                         using a divide-and-conquer algorithm.

                         ZHEEVX computes selected eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian matrix.

                         ZHEEVR computes selected eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian matrix
                         using the Relatively Robust Representation where it can.

                         ZHPEVD computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian matrix in packed
                         storage, using a divide-and-conquer algorithm.

                         ZHPEVX computes selected eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian matrix in packed
                         storage.

                         ZHBEVD computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian band matrix,
                         using a divide-and-conquer algorithm.

                         ZHBEVX computes selected eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian band matrix.

                         ZHEEV computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian matrix.

                         ZHPEV computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian matrix in packed
                         storage.

                         ZHBEV computes all eigenvalues and, optionally,
                         eigenvectors of a complex Hermitian band matrix.

                 When ZDRVST is called, a number of matrix "sizes" ("n's") and a
                 number of matrix "types" are specified.  For each size ("n")
                 and each type of matrix, one matrix will be generated and used
                 to test the appropriate drivers.  For each matrix and each
                 driver routine called, the following tests will be performed:

                 (1)     | A - Z D Z' | / ( |A| n ulp )

                 (2)     | I - Z Z' | / ( n ulp )

                 (3)     | D1 - D2 | / ( |D1| ulp )

                 where Z is the matrix of eigenvectors returned when the
                 eigenvector option is given and D1 and D2 are the eigenvalues
                 returned with and without the eigenvector option.

                 The "sizes" are specified by an array NN(1:NSIZES); the value of
                 each element 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 diagonal matrix with evenly spaced entries
                      1, ..., ULP  and random signs.
                      (ULP = (first number larger than 1) - 1 )
                 (4)  A diagonal matrix with geometrically spaced entries
                      1, ..., ULP  and random signs.
                 (5)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                      and random signs.

                 (6)  Same as (4), but multiplied by SQRT( overflow threshold )
                 (7)  Same as (4), but multiplied by SQRT( underflow threshold )

                 (8)  A matrix of the form  U* D U, where U is unitary and
                      D has evenly spaced entries 1, ..., ULP with random signs
                      on the diagonal.

                 (9)  A matrix of the form  U* D U, where U is unitary and
                      D has geometrically spaced entries 1, ..., ULP with random
                      signs on the diagonal.

                 (10) A matrix of the form  U* D U, where U is unitary and
                      D has "clustered" entries 1, ULP,..., ULP with random
                      signs on the diagonal.

                 (11) Same as (8), but multiplied by SQRT( overflow threshold )
                 (12) Same as (8), but multiplied by SQRT( underflow threshold )

                 (13) Symmetric matrix with random entries chosen from (-1,1).
                 (14) Same as (13), but multiplied by SQRT( overflow threshold )
                 (15) Same as (13), but multiplied by SQRT( underflow threshold )
                 (16) A band matrix with half bandwidth randomly chosen between
                      0 and N-1, with evenly spaced eigenvalues 1, ..., ULP
                      with random signs.
                 (17) Same as (16), but multiplied by SQRT( overflow threshold )
                 (18) Same as (16), but multiplied by SQRT( underflow threshold )

             NSIZES  INTEGER
                     The number of sizes of matrices to use.  If it is zero,
                     ZDRVST does nothing.  It must be at least zero.
                     Not modified.

             NN      INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.
                     Not modified.

             NTYPES  INTEGER
                     The number of elements in DOTYPE.   If it is zero, ZDRVST
                     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 matrix is in A.  This
                     is only useful if DOTYPE(1:MAXTYP) is .FALSE. and
                     DOTYPE(MAXTYP+1) is .TRUE. .
                     Not modified.

             DOTYPE  LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.
                     Not modified.

             ISEED   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 ZDRVST to continue the same random number
                     sequence.
                     Modified.

             THRESH  DOUBLE PRECISION
                     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.
                     Not modified.

             NOUNIT  INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns IINFO not equal to 0.)
                     Not modified.

             A       COMPLEX*16 array, dimension (LDA , max(NN))
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually
                     used.
                     Modified.

             LDA     INTEGER
                     The leading dimension of A.  It must be at
                     least 1 and at least max( NN ).
                     Not modified.

             D1      DOUBLE PRECISION array, dimension (max(NN))
                     The eigenvalues of A, as computed by ZSTEQR simlutaneously
                     with Z.  On exit, the eigenvalues in D1 correspond with the
                     matrix in A.
                     Modified.

             D2      DOUBLE PRECISION array, dimension (max(NN))
                     The eigenvalues of A, as computed by ZSTEQR if Z is not
                     computed.  On exit, the eigenvalues in D2 correspond with
                     the matrix in A.
                     Modified.

             D3      DOUBLE PRECISION array, dimension (max(NN))
                     The eigenvalues of A, as computed by DSTERF.  On exit, the
                     eigenvalues in D3 correspond with the matrix in A.
                     Modified.

             WA1     DOUBLE PRECISION array, dimension

             WA2     DOUBLE PRECISION array, dimension

             WA3     DOUBLE PRECISION array, dimension

             U       COMPLEX*16 array, dimension (LDU, max(NN))
                     The unitary matrix computed by ZHETRD + ZUNGC3.
                     Modified.

             LDU     INTEGER
                     The leading dimension of U, Z, and V.  It must be at
                     least 1 and at least max( NN ).
                     Not modified.

             V       COMPLEX*16 array, dimension (LDU, max(NN))
                     The Housholder vectors computed by ZHETRD in reducing A to
                     tridiagonal form.
                     Modified.

             TAU     COMPLEX*16 array, dimension (max(NN))
                     The Householder factors computed by ZHETRD in reducing A
                     to tridiagonal form.
                     Modified.

             Z       COMPLEX*16 array, dimension (LDU, max(NN))
                     The unitary matrix of eigenvectors computed by ZHEEVD,
                     ZHEEVX, ZHPEVD, CHPEVX, ZHBEVD, and CHBEVX.
                     Modified.

             WORK  - COMPLEX*16 array of dimension ( LWORK )
                      Workspace.
                      Modified.

             LWORK - INTEGER
                      The number of entries in WORK.  This must be at least
                      2*max( NN(j), 2 )**2.
                      Not modified.

             RWORK   DOUBLE PRECISION array, dimension (3*max(NN))
                      Workspace.
                      Modified.

             LRWORK - INTEGER
                      The number of entries in RWORK.

             IWORK   INTEGER array, dimension (6*max(NN))
                     Workspace.
                     Modified.

             LIWORK - INTEGER
                      The number of entries in IWORK.

             RESULT  DOUBLE PRECISION array, dimension (??)
                     The values computed by the tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.
                     Modified.

             INFO    INTEGER
                     If 0, then everything ran OK.
                      -1: NSIZES < 0
                      -2: Some NN(j) < 0
                      -3: NTYPES < 0
                      -5: THRESH < 0
                      -9: LDA < 1 or LDA < NMAX, where NMAX is max( NN(j) ).
                     -16: LDU < 1 or LDU < NMAX.
                     -21: LWORK too small.
                     If  DLATMR, SLATMS, ZHETRD, DORGC3, ZSTEQR, DSTERF,
                         or DORMC2 returns an error code, the
                         absolute value of it is returned.
                     Modified.

           -----------------------------------------------------------------------

                  Some Local Variables and Parameters:
                  ---- ----- --------- --- ----------
                  ZERO, ONE       Real 0 and 1.
                  MAXTYP          The number of types defined.
                  NTEST           The number of tests performed, or which can
                                  be performed so far, for the current matrix.
                  NTESTT          The total number of tests performed so far.
                  NMAX            Largest value in NN.
                  NMATS           The number of matrices generated so far.
                  NERRS           The number of tests which have exceeded THRESH
                                  so far (computed by DLAFTS).
                  COND, IMODE     Values to be passed to the matrix generators.
                  ANORM           Norm of A; passed to matrix generators.

                  OVFL, UNFL      Overflow and underflow thresholds.
                  ULP, ULPINV     Finest relative precision and its inverse.
                  RTOVFL, RTUNFL  Square roots of the previous 2 values.
                          The following four arrays decode JTYPE:
                  KTYPE(j)        The general type (1-10) for type "j".
                  KMODE(j)        The MODE value to be passed to the matrix
                                  generator for type "j".
                  KMAGN(j)        The order of magnitude ( O(1),
                                  O(overflow^(1/2) ), O(underflow^(1/2) )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvsx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NIUNIT, integer NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
       dimension( lda, * ) H, complex*16, dimension( lda, * ) HT, complex*16, dimension( * ) W,
       complex*16, dimension( * ) WT, complex*16, dimension( * ) WTMP, complex*16, dimension(
       ldvs, * ) VS, integer LDVS, complex*16, dimension( ldvs, * ) VS1, double precision,
       dimension( 17 ) RESULT, complex*16, dimension( * ) WORK, integer LWORK, double precision,
       dimension( * ) RWORK, logical, dimension( * ) BWORK, integer INFO)
       ZDRVSX

       Purpose:

               ZDRVSX checks the nonsymmetric eigenvalue (Schur form) problem
               expert driver ZGEESX.

               ZDRVSX uses both test matrices generated randomly depending on
               data supplied in the calling sequence, as well as on data
               read from an input file and including precomputed condition
               numbers to which it compares the ones it computes.

               When ZDRVSX is called, a number of matrix "sizes" ("n's") and a
               number of matrix "types" are specified.  For each size ("n")
               and each type of matrix, one matrix will be generated and used
               to test the nonsymmetric eigenroutines.  For each matrix, 15
               tests will be performed:

               (1)     0 if T is in Schur form, 1/ulp otherwise
                      (no sorting of eigenvalues)

               (2)     | A - VS T VS' | / ( n |A| ulp )

                 Here VS is the matrix of Schur eigenvectors, and T is in Schur
                 form  (no sorting of eigenvalues).

               (3)     | I - VS VS' | / ( n ulp ) (no sorting of eigenvalues).

               (4)     0     if W are eigenvalues of T
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (5)     0     if T(with VS) = T(without VS),
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (6)     0     if eigenvalues(with VS) = eigenvalues(without VS),
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (7)     0 if T is in Schur form, 1/ulp otherwise
                       (with sorting of eigenvalues)

               (8)     | A - VS T VS' | / ( n |A| ulp )

                 Here VS is the matrix of Schur eigenvectors, and T is in Schur
                 form  (with sorting of eigenvalues).

               (9)     | I - VS VS' | / ( n ulp ) (with sorting of eigenvalues).

               (10)    0     if W are eigenvalues of T
                       1/ulp otherwise
                       If workspace sufficient, also compare W with and
                       without reciprocal condition numbers
                       (with sorting of eigenvalues)

               (11)    0     if T(with VS) = T(without VS),
                       1/ulp otherwise
                       If workspace sufficient, also compare T with and without
                       reciprocal condition numbers
                       (with sorting of eigenvalues)

               (12)    0     if eigenvalues(with VS) = eigenvalues(without VS),
                       1/ulp otherwise
                       If workspace sufficient, also compare VS with and without
                       reciprocal condition numbers
                       (with sorting of eigenvalues)

               (13)    if sorting worked and SDIM is the number of
                       eigenvalues which were SELECTed
                       If workspace sufficient, also compare SDIM with and
                       without reciprocal condition numbers

               (14)    if RCONDE the same no matter if VS and/or RCONDV computed

               (15)    if RCONDV the same no matter if VS and/or RCONDE computed

               The "sizes" are specified by an array NN(1:NSIZES); the value of
               each element 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 (transposed) Jordan block, with 1's on the diagonal.

               (4)  A diagonal matrix with evenly spaced entries
                    1, ..., ULP  and random complex angles.
                    (ULP = (first number larger than 1) - 1 )
               (5)  A diagonal matrix with geometrically spaced entries
                    1, ..., ULP  and random complex angles.
               (6)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                    and random complex angles.

               (7)  Same as (4), but multiplied by a constant near
                    the overflow threshold
               (8)  Same as (4), but multiplied by a constant near
                    the underflow threshold

               (9)  A matrix of the form  U' T U, where U is unitary and
                    T has evenly spaced entries 1, ..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (10) A matrix of the form  U' T U, where U is unitary and
                    T has geometrically spaced entries 1, ..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (11) A matrix of the form  U' T U, where U is orthogonal and
                    T has "clustered" entries 1, ULP,..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (12) A matrix of the form  U' T U, where U is unitary and
                    T has complex eigenvalues randomly chosen from
                    ULP < |z| < 1   and random O(1) entries in the upper
                    triangle.

               (13) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (14) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has geometrically spaced entries
                    1, ..., ULP with random complex angles on the diagonal
                    and random O(1) entries in the upper triangle.

               (15) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (16) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has complex eigenvalues randomly chosen
                    from ULP < |z| < 1 and random O(1) entries in the upper
                    triangle.

               (17) Same as (16), but multiplied by a constant
                    near the overflow threshold
               (18) Same as (16), but multiplied by a constant
                    near the underflow threshold

               (19) Nonsymmetric matrix with random entries chosen from (-1,1).
                    If N is at least 4, all entries in first two rows and last
                    row, and first column and last two columns are zero.
               (20) Same as (19), but multiplied by a constant
                    near the overflow threshold
               (21) Same as (19), but multiplied by a constant
                    near the underflow threshold

               In addition, an input file will be read from logical unit number
               NIUNIT. The file contains matrices along with precomputed
               eigenvalues and reciprocal condition numbers for the eigenvalue
               average and right invariant subspace. For these matrices, in
               addition to tests (1) to (15) we will compute the following two
               tests:

              (16)  |RCONDE - RCDEIN| / cond(RCONDE)

                 RCONDE is the reciprocal average eigenvalue condition number
                 computed by ZGEESX and RCDEIN (the precomputed true value)
                 is supplied as input.  cond(RCONDE) is the condition number
                 of RCONDE, and takes errors in computing RCONDE into account,
                 so that the resulting quantity should be O(ULP). cond(RCONDE)
                 is essentially given by norm(A)/RCONDV.

              (17)  |RCONDV - RCDVIN| / cond(RCONDV)

                 RCONDV is the reciprocal right invariant subspace condition
                 number computed by ZGEESX and RCDVIN (the precomputed true
                 value) is supplied as input. cond(RCONDV) is the condition
                 number of RCONDV, and takes errors in computing RCONDV into
                 account, so that the resulting quantity should be O(ULP).
                 cond(RCONDV) is essentially given by norm(A)/RCONDE.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  NSIZES must be at
                     least zero. If it is zero, no randomly generated matrices
                     are tested, but any test matrices read from NIUNIT will be
                     tested.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE. NTYPES must be at least
                     zero. If it is zero, no randomly generated test matrices
                     are tested, but and test matrices read from NIUNIT will be
                     tested. If it is MAXTYP+1 and NSIZES is 1, then an
                     additional type, MAXTYP+1 is defined, which is to use
                     whatever matrix is in A.  This is only useful if
                     DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZDRVSX to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NIUNIT

                     NIUNIT is INTEGER
                     The FORTRAN unit number for reading in the data file of
                     problems to solve.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns INFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension (LDA, max(NN))
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually used.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, and H. LDA must be at
                     least 1 and at least max( NN ).

           H

                     H is COMPLEX*16 array, dimension (LDA, max(NN))
                     Another copy of the test matrix A, modified by ZGEESX.

           HT

                     HT is COMPLEX*16 array, dimension (LDA, max(NN))
                     Yet another copy of the test matrix A, modified by ZGEESX.

           W

                     W is COMPLEX*16 array, dimension (max(NN))
                     The computed eigenvalues of A.

           WT

                     WT is COMPLEX*16 array, dimension (max(NN))
                     Like W, this array contains the eigenvalues of A,
                     but those computed when ZGEESX only computes a partial
                     eigendecomposition, i.e. not Schur vectors

           WTMP

                     WTMP is COMPLEX*16 array, dimension (max(NN))
                     More temporary storage for eigenvalues.

           VS

                     VS is COMPLEX*16 array, dimension (LDVS, max(NN))
                     VS holds the computed Schur vectors.

           LDVS

                     LDVS is INTEGER
                     Leading dimension of VS. Must be at least max(1,max(NN)).

           VS1

                     VS1 is COMPLEX*16 array, dimension (LDVS, max(NN))
                     VS1 holds another copy of the computed Schur vectors.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (17)
                     The values computed by the 17 tests described above.
                     The values are currently limited to 1/ulp, to avoid overflow.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     max(1,2*NN(j)**2) for all j.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(NN))

           BWORK

                     BWORK is LOGICAL array, dimension (max(NN))

           INFO

                     INFO is INTEGER
                     If 0,  successful exit.
                       <0,  input parameter -INFO is incorrect
                       >0,  ZLATMR, CLATMS, CLATME or ZGET24 returned an error
                            code and INFO is its absolute value

           -----------------------------------------------------------------------

                Some Local Variables and Parameters:
                ---- ----- --------- --- ----------
                ZERO, ONE       Real 0 and 1.
                MAXTYP          The number of types defined.
                NMAX            Largest value in NN.
                NERRS           The number of tests which have exceeded THRESH
                COND, CONDS,
                IMODE           Values to be passed to the matrix generators.
                ANORM           Norm of A; passed to matrix generators.

                OVFL, UNFL      Overflow and underflow thresholds.
                ULP, ULPINV     Finest relative precision and its inverse.
                RTULP, RTULPI   Square roots of the previous 4 values.
                        The following four arrays decode JTYPE:
                KTYPE(j)        The general type (1-10) for type "j".
                KMODE(j)        The MODE value to be passed to the matrix
                                generator for type "j".
                KMAGN(j)        The order of magnitude ( O(1),
                                O(overflow^(1/2) ), O(underflow^(1/2) )
                KCONDS(j)       Selectw whether CONDS is to be 1 or
                                1/sqrt(ulp).  (0 means irrelevant.)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zdrvvx (integer NSIZES, integer, dimension( * ) NN, integer NTYPES, logical,
       dimension( * ) DOTYPE, integer, dimension( 4 ) ISEED, double precision THRESH, integer
       NIUNIT, integer NOUNIT, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
       dimension( lda, * ) H, complex*16, dimension( * ) W, complex*16, dimension( * ) W1,
       complex*16, dimension( ldvl, * ) VL, integer LDVL, complex*16, dimension( ldvr, * ) VR,
       integer LDVR, complex*16, dimension( ldlre, * ) LRE, integer LDLRE, double precision,
       dimension( * ) RCONDV, double precision, dimension( * ) RCNDV1, double precision,
       dimension( * ) RCDVIN, double precision, dimension( * ) RCONDE, double precision,
       dimension( * ) RCNDE1, double precision, dimension( * ) RCDEIN, double precision,
       dimension( * ) SCALE, double precision, dimension( * ) SCALE1, double precision,
       dimension( 11 ) RESULT, complex*16, dimension( * ) WORK, integer NWORK, double precision,
       dimension( * ) RWORK, integer INFO)
       ZDRVVX

       Purpose:

               ZDRVVX  checks the nonsymmetric eigenvalue problem expert driver
               ZGEEVX.

               ZDRVVX uses both test matrices generated randomly depending on
               data supplied in the calling sequence, as well as on data
               read from an input file and including precomputed condition
               numbers to which it compares the ones it computes.

               When ZDRVVX is called, a number of matrix "sizes" ("n's") and a
               number of matrix "types" are specified in the calling sequence.
               For each size ("n") and each type of matrix, one matrix will be
               generated and used to test the nonsymmetric eigenroutines.  For
               each matrix, 9 tests will be performed:

               (1)     | A * VR - VR * W | / ( n |A| ulp )

                 Here VR is the matrix of unit right eigenvectors.
                 W is a diagonal matrix with diagonal entries W(j).

               (2)     | A**H  * VL - VL * W**H | / ( n |A| ulp )

                 Here VL is the matrix of unit left eigenvectors, A**H is the
                 conjugate transpose of A, and W is as above.

               (3)     | |VR(i)| - 1 | / ulp and largest component real

                 VR(i) denotes the i-th column of VR.

               (4)     | |VL(i)| - 1 | / ulp and largest component real

                 VL(i) denotes the i-th column of VL.

               (5)     W(full) = W(partial)

                 W(full) denotes the eigenvalues computed when VR, VL, RCONDV
                 and RCONDE are also computed, and W(partial) denotes the
                 eigenvalues computed when only some of VR, VL, RCONDV, and
                 RCONDE are computed.

               (6)     VR(full) = VR(partial)

                 VR(full) denotes the right eigenvectors computed when VL, RCONDV
                 and RCONDE are computed, and VR(partial) denotes the result
                 when only some of VL and RCONDV are computed.

               (7)     VL(full) = VL(partial)

                 VL(full) denotes the left eigenvectors computed when VR, RCONDV
                 and RCONDE are computed, and VL(partial) denotes the result
                 when only some of VR and RCONDV are computed.

               (8)     0 if SCALE, ILO, IHI, ABNRM (full) =
                            SCALE, ILO, IHI, ABNRM (partial)
                       1/ulp otherwise

                 SCALE, ILO, IHI and ABNRM describe how the matrix is balanced.
                 (full) is when VR, VL, RCONDE and RCONDV are also computed, and
                 (partial) is when some are not computed.

               (9)     RCONDV(full) = RCONDV(partial)

                 RCONDV(full) denotes the reciprocal condition numbers of the
                 right eigenvectors computed when VR, VL and RCONDE are also
                 computed. RCONDV(partial) denotes the reciprocal condition
                 numbers when only some of VR, VL and RCONDE are computed.

               The "sizes" are specified by an array NN(1:NSIZES); the value of
               each element 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 (transposed) Jordan block, with 1's on the diagonal.

               (4)  A diagonal matrix with evenly spaced entries
                    1, ..., ULP  and random complex angles.
                    (ULP = (first number larger than 1) - 1 )
               (5)  A diagonal matrix with geometrically spaced entries
                    1, ..., ULP  and random complex angles.
               (6)  A diagonal matrix with "clustered" entries 1, ULP, ..., ULP
                    and random complex angles.

               (7)  Same as (4), but multiplied by a constant near
                    the overflow threshold
               (8)  Same as (4), but multiplied by a constant near
                    the underflow threshold

               (9)  A matrix of the form  U' T U, where U is unitary and
                    T has evenly spaced entries 1, ..., ULP with random complex
                    angles on the diagonal and random O(1) entries in the upper
                    triangle.

               (10) A matrix of the form  U' T U, where U is unitary and
                    T has geometrically spaced entries 1, ..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (11) A matrix of the form  U' T U, where U is unitary and
                    T has "clustered" entries 1, ULP,..., ULP with random
                    complex angles on the diagonal and random O(1) entries in
                    the upper triangle.

               (12) A matrix of the form  U' T U, where U is unitary and
                    T has complex eigenvalues randomly chosen from
                    ULP < |z| < 1   and random O(1) entries in the upper
                    triangle.

               (13) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has evenly spaced entries 1, ..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (14) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has geometrically spaced entries
                    1, ..., ULP with random complex angles on the diagonal
                    and random O(1) entries in the upper triangle.

               (15) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has "clustered" entries 1, ULP,..., ULP
                    with random complex angles on the diagonal and random O(1)
                    entries in the upper triangle.

               (16) A matrix of the form  X' T X, where X has condition
                    SQRT( ULP ) and T has complex eigenvalues randomly chosen
                    from ULP < |z| < 1 and random O(1) entries in the upper
                    triangle.

               (17) Same as (16), but multiplied by a constant
                    near the overflow threshold
               (18) Same as (16), but multiplied by a constant
                    near the underflow threshold

               (19) Nonsymmetric matrix with random entries chosen from |z| < 1
                    If N is at least 4, all entries in first two rows and last
                    row, and first column and last two columns are zero.
               (20) Same as (19), but multiplied by a constant
                    near the overflow threshold
               (21) Same as (19), but multiplied by a constant
                    near the underflow threshold

               In addition, an input file will be read from logical unit number
               NIUNIT. The file contains matrices along with precomputed
               eigenvalues and reciprocal condition numbers for the eigenvalues
               and right eigenvectors. For these matrices, in addition to tests
               (1) to (9) we will compute the following two tests:

              (10)  |RCONDV - RCDVIN| / cond(RCONDV)

                 RCONDV is the reciprocal right eigenvector condition number
                 computed by ZGEEVX and RCDVIN (the precomputed true value)
                 is supplied as input. cond(RCONDV) is the condition number of
                 RCONDV, and takes errors in computing RCONDV into account, so
                 that the resulting quantity should be O(ULP). cond(RCONDV) is
                 essentially given by norm(A)/RCONDE.

              (11)  |RCONDE - RCDEIN| / cond(RCONDE)

                 RCONDE is the reciprocal eigenvalue condition number
                 computed by ZGEEVX and RCDEIN (the precomputed true value)
                 is supplied as input.  cond(RCONDE) is the condition number
                 of RCONDE, and takes errors in computing RCONDE into account,
                 so that the resulting quantity should be O(ULP). cond(RCONDE)
                 is essentially given by norm(A)/RCONDV.

       Parameters:
           NSIZES

                     NSIZES is INTEGER
                     The number of sizes of matrices to use.  NSIZES must be at
                     least zero. If it is zero, no randomly generated matrices
                     are tested, but any test matrices read from NIUNIT will be
                     tested.

           NN

                     NN is INTEGER array, dimension (NSIZES)
                     An array containing the sizes to be used for the matrices.
                     Zero values will be skipped.  The values must be at least
                     zero.

           NTYPES

                     NTYPES is INTEGER
                     The number of elements in DOTYPE. NTYPES must be at least
                     zero. If it is zero, no randomly generated test matrices
                     are tested, but and test matrices read from NIUNIT will be
                     tested. If it is MAXTYP+1 and NSIZES is 1, then an
                     additional type, MAXTYP+1 is defined, which is to use
                     whatever matrix is in A.  This is only useful if
                     DOTYPE(1:MAXTYP) is .FALSE. and DOTYPE(MAXTYP+1) is .TRUE. .

           DOTYPE

                     DOTYPE is LOGICAL array, dimension (NTYPES)
                     If DOTYPE(j) is .TRUE., then for each size in NN a
                     matrix of that size and 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.

           ISEED

                     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 ZDRVVX to continue the same random number
                     sequence.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NIUNIT

                     NIUNIT is INTEGER
                     The FORTRAN unit number for reading in the data file of
                     problems to solve.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns INFO not equal to 0.)

           A

                     A is COMPLEX*16 array, dimension (LDA, max(NN,12))
                     Used to hold the matrix whose eigenvalues are to be
                     computed.  On exit, A contains the last matrix actually used.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, and H. LDA must be at
                     least 1 and at least max( NN, 12 ). (12 is the
                     dimension of the largest matrix on the precomputed
                     input file.)

           H

                     H is COMPLEX*16 array, dimension (LDA, max(NN,12))
                     Another copy of the test matrix A, modified by ZGEEVX.

           W

                     W is COMPLEX*16 array, dimension (max(NN,12))
                     Contains the eigenvalues of A.

           W1

                     W1 is COMPLEX*16 array, dimension (max(NN,12))
                     Like W, this array contains the eigenvalues of A,
                     but those computed when ZGEEVX only computes a partial
                     eigendecomposition, i.e. not the eigenvalues and left
                     and right eigenvectors.

           VL

                     VL is COMPLEX*16 array, dimension (LDVL, max(NN,12))
                     VL holds the computed left eigenvectors.

           LDVL

                     LDVL is INTEGER
                     Leading dimension of VL. Must be at least max(1,max(NN,12)).

           VR

                     VR is COMPLEX*16 array, dimension (LDVR, max(NN,12))
                     VR holds the computed right eigenvectors.

           LDVR

                     LDVR is INTEGER
                     Leading dimension of VR. Must be at least max(1,max(NN,12)).

           LRE

                     LRE is COMPLEX*16 array, dimension (LDLRE, max(NN,12))
                     LRE holds the computed right or left eigenvectors.

           LDLRE

                     LDLRE is INTEGER
                     Leading dimension of LRE. Must be at least max(1,max(NN,12))

           RCONDV

                     RCONDV is DOUBLE PRECISION array, dimension (N)
                     RCONDV holds the computed reciprocal condition numbers
                     for eigenvectors.

           RCNDV1

                     RCNDV1 is DOUBLE PRECISION array, dimension (N)
                     RCNDV1 holds more computed reciprocal condition numbers
                     for eigenvectors.

           RCDVIN

                     RCDVIN is DOUBLE PRECISION array, dimension (N)
                     When COMP = .TRUE. RCDVIN holds the precomputed reciprocal
                     condition numbers for eigenvectors to be compared with
                     RCONDV.

           RCONDE

                     RCONDE is DOUBLE PRECISION array, dimension (N)
                     RCONDE holds the computed reciprocal condition numbers
                     for eigenvalues.

           RCNDE1

                     RCNDE1 is DOUBLE PRECISION array, dimension (N)
                     RCNDE1 holds more computed reciprocal condition numbers
                     for eigenvalues.

           RCDEIN

                     RCDEIN is DOUBLE PRECISION array, dimension (N)
                     When COMP = .TRUE. RCDEIN holds the precomputed reciprocal
                     condition numbers for eigenvalues to be compared with
                     RCONDE.

           SCALE

                     SCALE is DOUBLE PRECISION array, dimension (N)
                     Holds information describing balancing of matrix.

           SCALE1

                     SCALE1 is DOUBLE PRECISION array, dimension (N)
                     Holds information describing balancing of matrix.

           WORK

                     WORK is COMPLEX*16 array, dimension (NWORK)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (11)
                     The values computed by the seven tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           NWORK

                     NWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     max(6*12+2*12**2,6*NN(j)+2*NN(j)**2) =
                     max(    360     ,6*NN(j)+2*NN(j)**2)    for all j.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*max(NN,12))

           INFO

                     INFO is INTEGER
                     If 0,  then successful exit.
                     If <0, then input parameter -INFO is incorrect.
                     If >0, ZLATMR, CLATMS, CLATME or ZGET23 returned an error
                            code, and INFO is its absolute value.

           -----------------------------------------------------------------------

                Some Local Variables and Parameters:
                ---- ----- --------- --- ----------

                ZERO, ONE       Real 0 and 1.
                MAXTYP          The number of types defined.
                NMAX            Largest value in NN or 12.
                NERRS           The number of tests which have exceeded THRESH
                COND, CONDS,
                IMODE           Values to be passed to the matrix generators.
                ANORM           Norm of A; passed to matrix generators.

                OVFL, UNFL      Overflow and underflow thresholds.
                ULP, ULPINV     Finest relative precision and its inverse.
                RTULP, RTULPI   Square roots of the previous 4 values.

                        The following four arrays decode JTYPE:
                KTYPE(j)        The general type (1-10) for type "j".
                KMODE(j)        The MODE value to be passed to the matrix
                                generator for type "j".
                KMAGN(j)        The order of magnitude ( O(1),
                                O(overflow^(1/2) ), O(underflow^(1/2) )
                KCONDS(j)       Selectw whether CONDS is to be 1 or
                                1/sqrt(ulp).  (0 means irrelevant.)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrbd (character*3 PATH, integer NUNIT)
       ZERRBD

       Purpose:

            ZERRBD tests the error exits for ZGEBRD, ZUNGBR, ZUNMBR, and ZBDSQR.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrec (character*3 PATH, integer NUNIT)
       ZERREC

       Purpose:

            ZERREC tests the error exits for the routines for eigen- condition
            estimation for DOUBLE PRECISION matrices:
               ZTRSYL, CTREXC, CTRSNA and CTRSEN.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerred (character*3 PATH, integer NUNIT)
       ZERRED

       Purpose:

            ZERRED tests the error exits for the eigenvalue driver routines for
            DOUBLE COMPLEX PRECISION matrices:

            PATH  driver   description
            ----  ------   -----------
            ZEV   ZGEEV    find eigenvalues/eigenvectors for nonsymmetric A
            ZES   ZGEES    find eigenvalues/Schur form for nonsymmetric A
            ZVX   ZGEEVX   ZGEEV + balancing and condition estimation
            ZSX   ZGEESX   ZGEES + balancing and condition estimation
            ZBD   ZGESVD   compute SVD of an M-by-N matrix A
                  ZGESDD   compute SVD of an M-by-N matrix A(by divide and
                           conquer)
                  ZGEJSV   compute SVD of an M-by-N matrix A where M >= N
                  ZGESVDX  compute SVD of an M-by-N matrix A(by bisection
                           and inverse iteration)

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrgg (character*3 PATH, integer NUNIT)
       ZERRGG

       Purpose:

            ZERRGG tests the error exits for ZGGES, ZGGESX, ZGGEV, ZGGEVX,
            ZGGES3, ZGGEV3, ZGGGLM, ZGGHRD, ZGGLSE, ZGGQRF, ZGGRQF,
            ZGGSVD3, ZGGSVP3, ZHGEQZ, ZTGEVC, ZTGEXC, ZTGSEN, ZTGSJA,
            ZTGSNA, ZTGSYL, and ZUNCSD.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2015

   subroutine zerrhs (character*3 PATH, integer NUNIT)
       ZERRHS

       Purpose:

            ZERRHS tests the error exits for ZGEBAK, CGEBAL, CGEHRD, ZUNGHR,
            ZUNMHR, ZHSEQR, CHSEIN, and ZTREVC.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zerrst (character*3 PATH, integer NUNIT)
       ZERRST

       Purpose:

            ZERRST tests the error exits for ZHETRD, ZUNGTR, CUNMTR, ZHPTRD,
            ZUNGTR, ZUPMTR, ZSTEQR, CSTEIN, ZPTEQR, ZHBTRD,
            ZHEEV, CHEEVX, CHEEVD, ZHBEV, CHBEVX, CHBEVD,
            ZHPEV, CHPEVX, CHPEVD, and ZSTEDC.

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The LAPACK path name for the routines to be tested.

           NUNIT

                     NUNIT is INTEGER
                     The unit number for output.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget02 (character TRANS, integer M, integer N, integer NRHS, complex*16, dimension(
       lda, * ) A, integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16,
       dimension( ldb, * ) B, integer LDB, double precision, dimension( * ) RWORK, double
       precision RESID)
       ZGET02

       Purpose:

            ZGET02 computes the residual for a solution of a system of linear
            equations  A*x = b  or  A'*x = b:
               RESID = norm(B - A*X) / ( norm(A) * norm(X) * EPS ),
            where EPS is the machine epsilon.

       Parameters:
           TRANS

                     TRANS is CHARACTER*1
                     Specifies the form of the system of equations:
                     = 'N':  A *x = b
                     = 'T':  A^T*x = b, where A^T is the transpose of A
                     = 'C':  A^H*x = b, where A^H is the conjugate transpose of A

           M

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

           N

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

           NRHS

                     NRHS is INTEGER
                     The number of columns of B, the matrix of right hand sides.
                     NRHS >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original M x N matrix A.

           LDA

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

           X

                     X is COMPLEX*16 array, dimension (LDX,NRHS)
                     The computed solution vectors for the system of linear
                     equations.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T' or 'C', LDX >= max(1,M).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     On entry, the right hand side vectors for the system of
                     linear equations.
                     On exit, B is overwritten with the difference B - A*X.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  IF TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T' or 'C', LDB >= max(1,N).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESID

                     RESID is DOUBLE PRECISION
                     The maximum over the number of right hand sides of
                     norm(B - A*X) / ( norm(A) * norm(X) * EPS ).

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget10 (integer M, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( * ) WORK, double
       precision, dimension( * ) RWORK, double precision RESULT)
       ZGET10

       Purpose:

            ZGET10 compares two matrices A and B and computes the ratio
            RESULT = norm( A - B ) / ( norm(A) * M * EPS )

       Parameters:
           M

                     M is INTEGER
                     The number of rows of the matrices A and B.

           N

                     N is INTEGER
                     The number of columns of the matrices A and B.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The m by n matrix A.

           LDA

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

           B

                     B is COMPLEX*16 array, dimension (LDB,N)
                     The m by n matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,M).

           WORK

                     WORK is COMPLEX*16 array, dimension (M)

           RWORK

                     RWORK is COMPLEX*16 array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION
                     RESULT = norm( A - B ) / ( norm(A) * M * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget22 (character TRANSA, character TRANSE, character TRANSW, integer N,
       complex*16, dimension( lda, * ) A, integer LDA, complex*16, dimension( lde, * ) E, integer
       LDE, complex*16, dimension( * ) W, complex*16, dimension( * ) WORK, double precision,
       dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
       ZGET22

       Purpose:

            ZGET22 does an eigenvector check.

            The basic test is:

               RESULT(1) = | A E  -  E W | / ( |A| |E| ulp )

            using the 1-norm.  It also tests the normalization of E:

               RESULT(2) = max | m-norm(E(j)) - 1 | / ( n ulp )
                            j

            where E(j) is the j-th eigenvector, and m-norm is the max-norm of a
            vector.  The max-norm of a complex n-vector x in this case is the
            maximum of |re(x(i)| + |im(x(i)| over i = 1, ..., n.

       Parameters:
           TRANSA

                     TRANSA is CHARACTER*1
                     Specifies whether or not A is transposed.
                     = 'N':  No transpose
                     = 'T':  Transpose
                     = 'C':  Conjugate transpose

           TRANSE

                     TRANSE is CHARACTER*1
                     Specifies whether or not E is transposed.
                     = 'N':  No transpose, eigenvectors are in columns of E
                     = 'T':  Transpose, eigenvectors are in rows of E
                     = 'C':  Conjugate transpose, eigenvectors are in rows of E

           TRANSW

                     TRANSW is CHARACTER*1
                     Specifies whether or not W is transposed.
                     = 'N':  No transpose
                     = 'T':  Transpose, same as TRANSW = 'N'
                     = 'C':  Conjugate transpose, use -WI(j) instead of WI(j)

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The matrix whose eigenvectors are in E.

           LDA

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

           E

                     E is COMPLEX*16 array, dimension (LDE,N)
                     The matrix of eigenvectors. If TRANSE = 'N', the eigenvectors
                     are stored in the columns of E, if TRANSE = 'T' or 'C', the
                     eigenvectors are stored in the rows of E.

           LDE

                     LDE is INTEGER
                     The leading dimension of the array E.  LDE >= max(1,N).

           W

                     W is COMPLEX*16 array, dimension (N)
                     The eigenvalues of A.

           WORK

                     WORK is COMPLEX*16 array, dimension (N*N)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     RESULT(1) = | A E  -  E W | / ( |A| |E| ulp )
                     RESULT(2) = max | m-norm(E(j)) - 1 | / ( n ulp )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget23 (logical COMP, integer ISRT, character BALANC, integer JTYPE, double
       precision THRESH, integer, dimension( 4 ) ISEED, integer NOUNIT, integer N, complex*16,
       dimension( lda, * ) A, integer LDA, complex*16, dimension( lda, * ) H, complex*16,
       dimension( * ) W, complex*16, dimension( * ) W1, complex*16, dimension( ldvl, * ) VL,
       integer LDVL, complex*16, dimension( ldvr, * ) VR, integer LDVR, complex*16, dimension(
       ldlre, * ) LRE, integer LDLRE, double precision, dimension( * ) RCONDV, double precision,
       dimension( * ) RCNDV1, double precision, dimension( * ) RCDVIN, double precision,
       dimension( * ) RCONDE, double precision, dimension( * ) RCNDE1, double precision,
       dimension( * ) RCDEIN, double precision, dimension( * ) SCALE, double precision,
       dimension( * ) SCALE1, double precision, dimension( 11 ) RESULT, complex*16, dimension( *
       ) WORK, integer LWORK, double precision, dimension( * ) RWORK, integer INFO)
       ZGET23

       Purpose:

               ZGET23  checks the nonsymmetric eigenvalue problem driver CGEEVX.
               If COMP = .FALSE., the first 8 of the following tests will be
               performed on the input matrix A, and also test 9 if LWORK is
               sufficiently large.
               if COMP is .TRUE. all 11 tests will be performed.

               (1)     | A * VR - VR * W | / ( n |A| ulp )

                 Here VR is the matrix of unit right eigenvectors.
                 W is a diagonal matrix with diagonal entries W(j).

               (2)     | A**H * VL - VL * W**H | / ( n |A| ulp )

                 Here VL is the matrix of unit left eigenvectors, A**H is the
                 conjugate transpose of A, and W is as above.

               (3)     | |VR(i)| - 1 | / ulp and largest component real

                 VR(i) denotes the i-th column of VR.

               (4)     | |VL(i)| - 1 | / ulp and largest component real

                 VL(i) denotes the i-th column of VL.

               (5)     0 if W(full) = W(partial), 1/ulp otherwise

                 W(full) denotes the eigenvalues computed when VR, VL, RCONDV
                 and RCONDE are also computed, and W(partial) denotes the
                 eigenvalues computed when only some of VR, VL, RCONDV, and
                 RCONDE are computed.

               (6)     0 if VR(full) = VR(partial), 1/ulp otherwise

                 VR(full) denotes the right eigenvectors computed when VL, RCONDV
                 and RCONDE are computed, and VR(partial) denotes the result
                 when only some of VL and RCONDV are computed.

               (7)     0 if VL(full) = VL(partial), 1/ulp otherwise

                 VL(full) denotes the left eigenvectors computed when VR, RCONDV
                 and RCONDE are computed, and VL(partial) denotes the result
                 when only some of VR and RCONDV are computed.

               (8)     0 if SCALE, ILO, IHI, ABNRM (full) =
                            SCALE, ILO, IHI, ABNRM (partial)
                       1/ulp otherwise

                 SCALE, ILO, IHI and ABNRM describe how the matrix is balanced.
                 (full) is when VR, VL, RCONDE and RCONDV are also computed, and
                 (partial) is when some are not computed.

               (9)     0 if RCONDV(full) = RCONDV(partial), 1/ulp otherwise

                 RCONDV(full) denotes the reciprocal condition numbers of the
                 right eigenvectors computed when VR, VL and RCONDE are also
                 computed. RCONDV(partial) denotes the reciprocal condition
                 numbers when only some of VR, VL and RCONDE are computed.

              (10)     |RCONDV - RCDVIN| / cond(RCONDV)

                 RCONDV is the reciprocal right eigenvector condition number
                 computed by ZGEEVX and RCDVIN (the precomputed true value)
                 is supplied as input. cond(RCONDV) is the condition number of
                 RCONDV, and takes errors in computing RCONDV into account, so
                 that the resulting quantity should be O(ULP). cond(RCONDV) is
                 essentially given by norm(A)/RCONDE.

              (11)     |RCONDE - RCDEIN| / cond(RCONDE)

                 RCONDE is the reciprocal eigenvalue condition number
                 computed by ZGEEVX and RCDEIN (the precomputed true value)
                 is supplied as input.  cond(RCONDE) is the condition number
                 of RCONDE, and takes errors in computing RCONDE into account,
                 so that the resulting quantity should be O(ULP). cond(RCONDE)
                 is essentially given by norm(A)/RCONDV.

       Parameters:
           COMP

                     COMP is LOGICAL
                     COMP describes which input tests to perform:
                       = .FALSE. if the computed condition numbers are not to
                                 be tested against RCDVIN and RCDEIN
                       = .TRUE.  if they are to be compared

           ISRT

                     ISRT is INTEGER
                     If COMP = .TRUE., ISRT indicates in how the eigenvalues
                     corresponding to values in RCDVIN and RCDEIN are ordered:
                       = 0 means the eigenvalues are sorted by
                           increasing real part
                       = 1 means the eigenvalues are sorted by
                           increasing imaginary part
                     If COMP = .FALSE., ISRT is not referenced.

           BALANC

                     BALANC is CHARACTER
                     Describes the balancing option to be tested.
                       = 'N' for no permuting or diagonal scaling
                       = 'P' for permuting but no diagonal scaling
                       = 'S' for no permuting but diagonal scaling
                       = 'B' for permuting and diagonal scaling

           JTYPE

                     JTYPE is INTEGER
                     Type of input matrix. Used to label output if error occurs.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     If COMP = .FALSE., the random number generator seed
                     used to produce matrix.
                     If COMP = .TRUE., ISEED(1) = the number of the example.
                     Used to label output if error occurs.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns INFO not equal to 0.)

           N

                     N is INTEGER
                     The dimension of A. N must be at least 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     Used to hold the matrix whose eigenvalues are to be
                     computed.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, and H. LDA must be at
                     least 1 and at least N.

           H

                     H is COMPLEX*16 array, dimension (LDA,N)
                     Another copy of the test matrix A, modified by ZGEEVX.

           W

                     W is COMPLEX*16 array, dimension (N)
                     Contains the eigenvalues of A.

           W1

                     W1 is COMPLEX*16 array, dimension (N)
                     Like W, this array contains the eigenvalues of A,
                     but those computed when ZGEEVX only computes a partial
                     eigendecomposition, i.e. not the eigenvalues and left
                     and right eigenvectors.

           VL

                     VL is COMPLEX*16 array, dimension (LDVL,N)
                     VL holds the computed left eigenvectors.

           LDVL

                     LDVL is INTEGER
                     Leading dimension of VL. Must be at least max(1,N).

           VR

                     VR is COMPLEX*16 array, dimension (LDVR,N)
                     VR holds the computed right eigenvectors.

           LDVR

                     LDVR is INTEGER
                     Leading dimension of VR. Must be at least max(1,N).

           LRE

                     LRE is COMPLEX*16 array, dimension (LDLRE,N)
                     LRE holds the computed right or left eigenvectors.

           LDLRE

                     LDLRE is INTEGER
                     Leading dimension of LRE. Must be at least max(1,N).

           RCONDV

                     RCONDV is DOUBLE PRECISION array, dimension (N)
                     RCONDV holds the computed reciprocal condition numbers
                     for eigenvectors.

           RCNDV1

                     RCNDV1 is DOUBLE PRECISION array, dimension (N)
                     RCNDV1 holds more computed reciprocal condition numbers
                     for eigenvectors.

           RCDVIN

                     RCDVIN is DOUBLE PRECISION array, dimension (N)
                     When COMP = .TRUE. RCDVIN holds the precomputed reciprocal
                     condition numbers for eigenvectors to be compared with
                     RCONDV.

           RCONDE

                     RCONDE is DOUBLE PRECISION array, dimension (N)
                     RCONDE holds the computed reciprocal condition numbers
                     for eigenvalues.

           RCNDE1

                     RCNDE1 is DOUBLE PRECISION array, dimension (N)
                     RCNDE1 holds more computed reciprocal condition numbers
                     for eigenvalues.

           RCDEIN

                     RCDEIN is DOUBLE PRECISION array, dimension (N)
                     When COMP = .TRUE. RCDEIN holds the precomputed reciprocal
                     condition numbers for eigenvalues to be compared with
                     RCONDE.

           SCALE

                     SCALE is DOUBLE PRECISION array, dimension (N)
                     Holds information describing balancing of matrix.

           SCALE1

                     SCALE1 is DOUBLE PRECISION array, dimension (N)
                     Holds information describing balancing of matrix.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (11)
                     The values computed by the 11 tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK.  This must be at least
                     2*N, and 2*N+N**2 if tests 9, 10 or 11 are to be performed.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (2*N)

           INFO

                     INFO is INTEGER
                     If 0,  successful exit.
                     If <0, input parameter -INFO had an incorrect value.
                     If >0, ZGEEVX returned an error code, the absolute
                            value of which is returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget24 (logical COMP, integer JTYPE, double precision THRESH, integer, dimension( 4
       ) ISEED, integer NOUNIT, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( lda, * ) H, complex*16, dimension( lda, * ) HT, complex*16,
       dimension( * ) W, complex*16, dimension( * ) WT, complex*16, dimension( * ) WTMP,
       complex*16, dimension( ldvs, * ) VS, integer LDVS, complex*16, dimension( ldvs, * ) VS1,
       double precision RCDEIN, double precision RCDVIN, integer NSLCT, integer, dimension( * )
       ISLCT, integer ISRT, double precision, dimension( 17 ) RESULT, complex*16, dimension( * )
       WORK, integer LWORK, double precision, dimension( * ) RWORK, logical, dimension( * )
       BWORK, integer INFO)
       ZGET24

       Purpose:

               ZGET24 checks the nonsymmetric eigenvalue (Schur form) problem
               expert driver ZGEESX.

               If COMP = .FALSE., the first 13 of the following tests will be
               be performed on the input matrix A, and also tests 14 and 15
               if LWORK is sufficiently large.
               If COMP = .TRUE., all 17 test will be performed.

               (1)     0 if T is in Schur form, 1/ulp otherwise
                      (no sorting of eigenvalues)

               (2)     | A - VS T VS' | / ( n |A| ulp )

                 Here VS is the matrix of Schur eigenvectors, and T is in Schur
                 form  (no sorting of eigenvalues).

               (3)     | I - VS VS' | / ( n ulp ) (no sorting of eigenvalues).

               (4)     0     if W are eigenvalues of T
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (5)     0     if T(with VS) = T(without VS),
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (6)     0     if eigenvalues(with VS) = eigenvalues(without VS),
                       1/ulp otherwise
                       (no sorting of eigenvalues)

               (7)     0 if T is in Schur form, 1/ulp otherwise
                       (with sorting of eigenvalues)

               (8)     | A - VS T VS' | / ( n |A| ulp )

                 Here VS is the matrix of Schur eigenvectors, and T is in Schur
                 form  (with sorting of eigenvalues).

               (9)     | I - VS VS' | / ( n ulp ) (with sorting of eigenvalues).

               (10)    0     if W are eigenvalues of T
                       1/ulp otherwise
                       If workspace sufficient, also compare W with and
                       without reciprocal condition numbers
                       (with sorting of eigenvalues)

               (11)    0     if T(with VS) = T(without VS),
                       1/ulp otherwise
                       If workspace sufficient, also compare T with and without
                       reciprocal condition numbers
                       (with sorting of eigenvalues)

               (12)    0     if eigenvalues(with VS) = eigenvalues(without VS),
                       1/ulp otherwise
                       If workspace sufficient, also compare VS with and without
                       reciprocal condition numbers
                       (with sorting of eigenvalues)

               (13)    if sorting worked and SDIM is the number of
                       eigenvalues which were SELECTed
                       If workspace sufficient, also compare SDIM with and
                       without reciprocal condition numbers

               (14)    if RCONDE the same no matter if VS and/or RCONDV computed

               (15)    if RCONDV the same no matter if VS and/or RCONDE computed

               (16)  |RCONDE - RCDEIN| / cond(RCONDE)

                  RCONDE is the reciprocal average eigenvalue condition number
                  computed by ZGEESX and RCDEIN (the precomputed true value)
                  is supplied as input.  cond(RCONDE) is the condition number
                  of RCONDE, and takes errors in computing RCONDE into account,
                  so that the resulting quantity should be O(ULP). cond(RCONDE)
                  is essentially given by norm(A)/RCONDV.

               (17)  |RCONDV - RCDVIN| / cond(RCONDV)

                  RCONDV is the reciprocal right invariant subspace condition
                  number computed by ZGEESX and RCDVIN (the precomputed true
                  value) is supplied as input. cond(RCONDV) is the condition
                  number of RCONDV, and takes errors in computing RCONDV into
                  account, so that the resulting quantity should be O(ULP).
                  cond(RCONDV) is essentially given by norm(A)/RCONDE.

       Parameters:
           COMP

                     COMP is LOGICAL
                     COMP describes which input tests to perform:
                       = .FALSE. if the computed condition numbers are not to
                                 be tested against RCDVIN and RCDEIN
                       = .TRUE.  if they are to be compared

           JTYPE

                     JTYPE is INTEGER
                     Type of input matrix. Used to label output if error occurs.

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     If COMP = .FALSE., the random number generator seed
                     used to produce matrix.
                     If COMP = .TRUE., ISEED(1) = the number of the example.
                     Used to label output if error occurs.

           THRESH

                     THRESH is DOUBLE PRECISION
                     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.

           NOUNIT

                     NOUNIT is INTEGER
                     The FORTRAN unit number for printing out error messages
                     (e.g., if a routine returns INFO not equal to 0.)

           N

                     N is INTEGER
                     The dimension of A. N must be at least 0.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     Used to hold the matrix whose eigenvalues are to be
                     computed.

           LDA

                     LDA is INTEGER
                     The leading dimension of A, and H. LDA must be at
                     least 1 and at least N.

           H

                     H is COMPLEX*16 array, dimension (LDA, N)
                     Another copy of the test matrix A, modified by ZGEESX.

           HT

                     HT is COMPLEX*16 array, dimension (LDA, N)
                     Yet another copy of the test matrix A, modified by ZGEESX.

           W

                     W is COMPLEX*16 array, dimension (N)
                     The computed eigenvalues of A.

           WT

                     WT is COMPLEX*16 array, dimension (N)
                     Like W, this array contains the eigenvalues of A,
                     but those computed when ZGEESX only computes a partial
                     eigendecomposition, i.e. not Schur vectors

           WTMP

                     WTMP is COMPLEX*16 array, dimension (N)
                     Like W, this array contains the eigenvalues of A,
                     but sorted by increasing real or imaginary part.

           VS

                     VS is COMPLEX*16 array, dimension (LDVS, N)
                     VS holds the computed Schur vectors.

           LDVS

                     LDVS is INTEGER
                     Leading dimension of VS. Must be at least max(1, N).

           VS1

                     VS1 is COMPLEX*16 array, dimension (LDVS, N)
                     VS1 holds another copy of the computed Schur vectors.

           RCDEIN

                     RCDEIN is DOUBLE PRECISION
                     When COMP = .TRUE. RCDEIN holds the precomputed reciprocal
                     condition number for the average of selected eigenvalues.

           RCDVIN

                     RCDVIN is DOUBLE PRECISION
                     When COMP = .TRUE. RCDVIN holds the precomputed reciprocal
                     condition number for the selected right invariant subspace.

           NSLCT

                     NSLCT is INTEGER
                     When COMP = .TRUE. the number of selected eigenvalues
                     corresponding to the precomputed values RCDEIN and RCDVIN.

           ISLCT

                     ISLCT is INTEGER array, dimension (NSLCT)
                     When COMP = .TRUE. ISLCT selects the eigenvalues of the
                     input matrix corresponding to the precomputed values RCDEIN
                     and RCDVIN. For I=1, ... ,NSLCT, if ISLCT(I) = J, then the
                     eigenvalue with the J-th largest real or imaginary part is
                     selected. The real part is used if ISRT = 0, and the
                     imaginary part if ISRT = 1.
                     Not referenced if COMP = .FALSE.

           ISRT

                     ISRT is INTEGER
                     When COMP = .TRUE., ISRT describes how ISLCT is used to
                     choose a subset of the spectrum.
                     Not referenced if COMP = .FALSE.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (17)
                     The values computed by the 17 tests described above.
                     The values are currently limited to 1/ulp, to avoid
                     overflow.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N*N)

           LWORK

                     LWORK is INTEGER
                     The number of entries in WORK to be passed to ZGEESX. This
                     must be at least 2*N, and N*(N+1)/2 if tests 14--16 are to
                     be performed.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           BWORK

                     BWORK is LOGICAL array, dimension (N)

           INFO

                     INFO is INTEGER
                     If 0,  successful exit.
                     If <0, input parameter -INFO had an incorrect value.
                     If >0, ZGEESX returned an error code, the absolute
                            value of which is returned.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget35 (double precision RMAX, integer LMAX, integer NINFO, integer KNT, integer
       NIN)
       ZGET35

       Purpose:

            ZGET35 tests ZTRSYL, a routine for solving the Sylvester matrix
            equation

               op(A)*X + ISGN*X*op(B) = scale*C,

            A and B are assumed to be in Schur canonical form, op() represents an
            optional transpose, and ISGN can be -1 or +1.  Scale is an output
            less than or equal to 1, chosen to avoid overflow in X.

            The test code verifies that the following residual is order 1:

               norm(op(A)*X + ISGN*X*op(B) - scale*C) /
                   (EPS*max(norm(A),norm(B))*norm(X))

       Parameters:
           RMAX

                     RMAX is DOUBLE PRECISION
                     Value of the largest test ratio.

           LMAX

                     LMAX is INTEGER
                     Example number where largest test ratio achieved.

           NINFO

                     NINFO is INTEGER
                     Number of examples where INFO is nonzero.

           KNT

                     KNT is INTEGER
                     Total number of examples tested.

           NIN

                     NIN is INTEGER
                     Input logical unit number.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget36 (double precision RMAX, integer LMAX, integer NINFO, integer KNT, integer
       NIN)
       ZGET36

       Purpose:

            ZGET36 tests ZTREXC, a routine for reordering diagonal entries of a
            matrix in complex Schur form. Thus, ZLAEXC computes a unitary matrix
            Q such that

               Q' * T1 * Q  = T2

            and where one of the diagonal blocks of T1 (the one at row IFST) has
            been moved to position ILST.

            The test code verifies that the residual Q'*T1*Q-T2 is small, that T2
            is in Schur form, and that the final position of the IFST block is
            ILST.

            The test matrices are read from a file with logical unit number NIN.

       Parameters:
           RMAX

                     RMAX is DOUBLE PRECISION
                     Value of the largest test ratio.

           LMAX

                     LMAX is INTEGER
                     Example number where largest test ratio achieved.

           NINFO

                     NINFO is INTEGER
                     Number of examples where INFO is nonzero.

           KNT

                     KNT is INTEGER
                     Total number of examples tested.

           NIN

                     NIN is INTEGER
                     Input logical unit number.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget37 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX,
       integer, dimension( 3 ) NINFO, integer KNT, integer NIN)
       ZGET37

       Purpose:

            ZGET37 tests ZTRSNA, a routine for estimating condition numbers of
            eigenvalues and/or right eigenvectors of a matrix.

            The test matrices are read from a file with logical unit number NIN.

       Parameters:
           RMAX

                     RMAX is DOUBLE PRECISION array, dimension (3)
                     Value of the largest test ratio.
                     RMAX(1) = largest ratio comparing different calls to ZTRSNA
                     RMAX(2) = largest error in reciprocal condition
                               numbers taking their conditioning into account
                     RMAX(3) = largest error in reciprocal condition
                               numbers not taking their conditioning into
                               account (may be larger than RMAX(2))

           LMAX

                     LMAX is INTEGER array, dimension (3)
                     LMAX(i) is example number where largest test ratio
                     RMAX(i) is achieved. Also:
                     If ZGEHRD returns INFO nonzero on example i, LMAX(1)=i
                     If ZHSEQR returns INFO nonzero on example i, LMAX(2)=i
                     If ZTRSNA returns INFO nonzero on example i, LMAX(3)=i

           NINFO

                     NINFO is INTEGER array, dimension (3)
                     NINFO(1) = No. of times ZGEHRD returned INFO nonzero
                     NINFO(2) = No. of times ZHSEQR returned INFO nonzero
                     NINFO(3) = No. of times ZTRSNA returned INFO nonzero

           KNT

                     KNT is INTEGER
                     Total number of examples tested.

           NIN

                     NIN is INTEGER
                     Input logical unit number

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget38 (double precision, dimension( 3 ) RMAX, integer, dimension( 3 ) LMAX,
       integer, dimension( 3 ) NINFO, integer KNT, integer NIN)
       ZGET38

       Purpose:

            ZGET38 tests ZTRSEN, a routine for estimating condition numbers of a
            cluster of eigenvalues and/or its associated right invariant subspace

            The test matrices are read from a file with logical unit number NIN.

       Parameters:
           RMAX

                     RMAX is DOUBLE PRECISION array, dimension (3)
                     Values of the largest test ratios.
                     RMAX(1) = largest residuals from ZHST01 or comparing
                               different calls to ZTRSEN
                     RMAX(2) = largest error in reciprocal condition
                               numbers taking their conditioning into account
                     RMAX(3) = largest error in reciprocal condition
                               numbers not taking their conditioning into
                               account (may be larger than RMAX(2))

           LMAX

                     LMAX is INTEGER array, dimension (3)
                     LMAX(i) is example number where largest test ratio
                     RMAX(i) is achieved. Also:
                     If ZGEHRD returns INFO nonzero on example i, LMAX(1)=i
                     If ZHSEQR returns INFO nonzero on example i, LMAX(2)=i
                     If ZTRSEN returns INFO nonzero on example i, LMAX(3)=i

           NINFO

                     NINFO is INTEGER array, dimension (3)
                     NINFO(1) = No. of times ZGEHRD returned INFO nonzero
                     NINFO(2) = No. of times ZHSEQR returned INFO nonzero
                     NINFO(3) = No. of times ZTRSEN returned INFO nonzero

           KNT

                     KNT is INTEGER
                     Total number of examples tested.

           NIN

                     NIN is INTEGER
                     Input logical unit number.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget51 (integer ITYPE, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( ldu, * ) U, integer
       LDU, complex*16, dimension( ldv, * ) V, integer LDV, complex*16, dimension( * ) WORK,
       double precision, dimension( * ) RWORK, double precision RESULT)
       ZGET51

       Purpose:

                 ZGET51  generally checks a decomposition of the form

                         A = U B VC>
                 where * means conjugate transpose and U and V are unitary.

                 Specifically, if ITYPE=1

                         RESULT = | A - U B V* | / ( |A| n ulp )

                 If ITYPE=2, then:

                         RESULT = | A - B | / ( |A| n ulp )

                 If ITYPE=3, then:

                         RESULT = | I - UU* | / ( n ulp )

       Parameters:
           ITYPE

                     ITYPE is INTEGER
                     Specifies the type of tests to be performed.
                     =1: RESULT = | A - U B V* | / ( |A| n ulp )
                     =2: RESULT = | A - B | / ( |A| n ulp )
                     =3: RESULT = | I - UU* | / ( n ulp )

           N

                     N is INTEGER
                     The size of the matrix.  If it is zero, ZGET51 does nothing.
                     It must be at least zero.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The original (unfactored) matrix.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at least 1
                     and at least N.

           B

                     B is COMPLEX*16 array, dimension (LDB, N)
                     The factored matrix.

           LDB

                     LDB is INTEGER
                     The leading dimension of B.  It must be at least 1
                     and at least N.

           U

                     U is COMPLEX*16 array, dimension (LDU, N)
                     The unitary matrix on the left-hand side in the
                     decomposition.
                     Not referenced if ITYPE=2

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  LDU must be at least N and
                     at least 1.

           V

                     V is COMPLEX*16 array, dimension (LDV, N)
                     The unitary matrix on the left-hand side in the
                     decomposition.
                     Not referenced if ITYPE=2

           LDV

                     LDV is INTEGER
                     The leading dimension of V.  LDV must be at least N and
                     at least 1.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N**2)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION
                     The values computed by the test specified by ITYPE.  The
                     value is currently limited to 1/ulp, to avoid overflow.
                     Errors are flagged by RESULT=10/ulp.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget52 (logical LEFT, integer N, complex*16, dimension( lda, * ) A, integer LDA,
       complex*16, dimension( ldb, * ) B, integer LDB, complex*16, dimension( lde, * ) E, integer
       LDE, complex*16, dimension( * ) ALPHA, complex*16, dimension( * ) BETA, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision, dimension(
       2 ) RESULT)
       ZGET52

       Purpose:

            ZGET52  does an eigenvector check for the generalized eigenvalue
            problem.

            The basic test for right eigenvectors is:

                                      | b(i) A E(i) -  a(i) B E(i) |
                    RESULT(1) = max   -------------------------------
                                 i    n ulp max( |b(i) A|, |a(i) B| )

            using the 1-norm.  Here, a(i)/b(i) = w is the i-th generalized
            eigenvalue of A - w B, or, equivalently, b(i)/a(i) = m is the i-th
            generalized eigenvalue of m A - B.

                                    H   H  _      _
            For left eigenvectors, A , B , a, and b  are used.

            ZGET52 also tests the normalization of E.  Each eigenvector is
            supposed to be normalized so that the maximum "absolute value"
            of its elements is 1, where in this case, "absolute value"
            of a complex value x is  |Re(x)| + |Im(x)| ; let us call this
            maximum "absolute value" norm of a vector v  M(v).
            If a(i)=b(i)=0, then the eigenvector is set to be the jth coordinate
            vector. The normalization test is:

                    RESULT(2) =      max       | M(v(i)) - 1 | / ( n ulp )
                               eigenvectors v(i)

       Parameters:
           LEFT

                     LEFT is LOGICAL
                     =.TRUE.:  The eigenvectors in the columns of E are assumed
                               to be *left* eigenvectors.
                     =.FALSE.: The eigenvectors in the columns of E are assumed
                               to be *right* eigenvectors.

           N

                     N is INTEGER
                     The size of the matrices.  If it is zero, ZGET52 does
                     nothing.  It must be at least zero.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at least 1
                     and at least N.

           B

                     B is COMPLEX*16 array, dimension (LDB, N)
                     The matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of B.  It must be at least 1
                     and at least N.

           E

                     E is COMPLEX*16 array, dimension (LDE, N)
                     The matrix of eigenvectors.  It must be O( 1 ).

           LDE

                     LDE is INTEGER
                     The leading dimension of E.  It must be at least 1 and at
                     least N.

           ALPHA

                     ALPHA is COMPLEX*16 array, dimension (N)
                     The values a(i) as described above, which, along with b(i),
                     define the generalized eigenvalues.

           BETA

                     BETA is COMPLEX*16 array, dimension (N)
                     The values b(i) as described above, which, along with a(i),
                     define the generalized eigenvalues.

           WORK

                     WORK is COMPLEX*16 array, dimension (N**2)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the test described above.  If A E or
                     B E is likely to overflow, then RESULT(1:2) is set to
                     10 / ulp.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zget54 (integer N, complex*16, dimension( lda, * ) A, integer LDA, complex*16,
       dimension( ldb, * ) B, integer LDB, complex*16, dimension( lds, * ) S, integer LDS,
       complex*16, dimension( ldt, * ) T, integer LDT, complex*16, dimension( ldu, * ) U, integer
       LDU, complex*16, dimension( ldv, * ) V, integer LDV, complex*16, dimension( * ) WORK,
       double precision RESULT)
       ZGET54

       Purpose:

            ZGET54 checks a generalized decomposition of the form

                     A = U*S*V'  and B = U*T* V'

            where ' means conjugate transpose and U and V are unitary.

            Specifically,

              RESULT = ||( A - U*S*V', B - U*T*V' )|| / (||( A, B )||*n*ulp )

       Parameters:
           N

                     N is INTEGER
                     The size of the matrix.  If it is zero, DGET54 does nothing.
                     It must be at least zero.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The original (unfactored) matrix A.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at least 1
                     and at least N.

           B

                     B is COMPLEX*16 array, dimension (LDB, N)
                     The original (unfactored) matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of B.  It must be at least 1
                     and at least N.

           S

                     S is COMPLEX*16 array, dimension (LDS, N)
                     The factored matrix S.

           LDS

                     LDS is INTEGER
                     The leading dimension of S.  It must be at least 1
                     and at least N.

           T

                     T is COMPLEX*16 array, dimension (LDT, N)
                     The factored matrix T.

           LDT

                     LDT is INTEGER
                     The leading dimension of T.  It must be at least 1
                     and at least N.

           U

                     U is COMPLEX*16 array, dimension (LDU, N)
                     The orthogonal matrix on the left-hand side in the
                     decomposition.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  LDU must be at least N and
                     at least 1.

           V

                     V is COMPLEX*16 array, dimension (LDV, N)
                     The orthogonal matrix on the left-hand side in the
                     decomposition.

           LDV

                     LDV is INTEGER
                     The leading dimension of V.  LDV must be at least N and
                     at least 1.

           WORK

                     WORK is COMPLEX*16 array, dimension (3*N**2)

           RESULT

                     RESULT is DOUBLE PRECISION
                     The value RESULT, It is currently limited to 1/ulp, to
                     avoid overflow. Errors are flagged by RESULT=10/ulp.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zglmts (integer N, integer M, integer P, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( ldb, * ) B,
       complex*16, dimension( ldb, * ) BF, integer LDB, complex*16, dimension( * ) D, complex*16,
       dimension( * ) DF, complex*16, dimension( * ) X, complex*16, dimension( * ) U, complex*16,
       dimension( lwork ) WORK, integer LWORK, double precision, dimension( * ) RWORK, double
       precision RESULT)
       ZGLMTS

       Purpose:

            ZGLMTS tests ZGGGLM - a subroutine for solving the generalized
            linear model problem.

       Parameters:
           N

                     N is INTEGER
                     The number of rows of the matrices A and B.  N >= 0.

           M

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

           P

                     P is INTEGER
                     The number of columns of the matrix B.  P >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,M)
                     The N-by-M matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,M)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF. LDA >= max(M,N).

           B

                     B is COMPLEX*16 array, dimension (LDB,P)
                     The N-by-P matrix A.

           BF

                     BF is COMPLEX*16 array, dimension (LDB,P)

           LDB

                     LDB is INTEGER
                     The leading dimension of the arrays B, BF. LDB >= max(P,N).

           D

                     D is COMPLEX*16 array, dimension( N )
                     On input, the left hand side of the GLM.

           DF

                     DF is COMPLEX*16 array, dimension( N )

           X

                     X is COMPLEX*16 array, dimension( M )
                     solution vector X in the GLM problem.

           U

                     U is COMPLEX*16 array, dimension( P )
                     solution vector U in the GLM problem.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION
                     The test ratio:
                                      norm( d - A*x - B*u )
                       RESULT = -----------------------------------------
                                (norm(A)+norm(B))*(norm(x)+norm(u))*EPS

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgqrts (integer N, integer M, integer P, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
       dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAUA, complex*16,
       dimension( ldb, * ) B, complex*16, dimension( ldb, * ) BF, complex*16, dimension( ldb, * )
       Z, complex*16, dimension( ldb, * ) T, complex*16, dimension( ldb, * ) BWK, integer LDB,
       complex*16, dimension( * ) TAUB, complex*16, dimension( lwork ) WORK, integer LWORK,
       double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)
       ZGQRTS

       Purpose:

            ZGQRTS tests ZGGQRF, which computes the GQR factorization of an
            N-by-M matrix A and a N-by-P matrix B: A = Q*R and B = Q*T*Z.

       Parameters:
           N

                     N is INTEGER
                     The number of rows of the matrices A and B.  N >= 0.

           M

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

           P

                     P is INTEGER
                     The number of columns of the matrix B.  P >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,M)
                     The N-by-M matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the GQR factorization of A and B, as returned
                     by ZGGQRF, see CGGQRF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)
                     The M-by-M unitary matrix Q.

           R

                     R is COMPLEX*16 array, dimension (LDA,MAX(M,N))

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, R and Q.
                     LDA >= max(M,N).

           TAUA

                     TAUA is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors, as returned
                     by ZGGQRF.

           B

                     B is COMPLEX*16 array, dimension (LDB,P)
                     On entry, the N-by-P matrix A.

           BF

                     BF is COMPLEX*16 array, dimension (LDB,N)
                     Details of the GQR factorization of A and B, as returned
                     by ZGGQRF, see CGGQRF for further details.

           Z

                     Z is COMPLEX*16 array, dimension (LDB,P)
                     The P-by-P unitary matrix Z.

           T

                     T is COMPLEX*16 array, dimension (LDB,max(P,N))

           BWK

                     BWK is COMPLEX*16 array, dimension (LDB,N)

           LDB

                     LDB is INTEGER
                     The leading dimension of the arrays B, BF, Z and T.
                     LDB >= max(P,N).

           TAUB

                     TAUB is COMPLEX*16 array, dimension (min(P,N))
                     The scalar factors of the elementary reflectors, as returned
                     by DGGRQF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK, LWORK >= max(N,M,P)**2.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(N,M,P))

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The test ratios:
                       RESULT(1) = norm( R - Q'*A ) / ( MAX(M,N)*norm(A)*ULP)
                       RESULT(2) = norm( T*Z - Q'*B ) / (MAX(P,N)*norm(B)*ULP)
                       RESULT(3) = norm( I - Q'*Q ) / ( M*ULP )
                       RESULT(4) = norm( I - Z'*Z ) / ( P*ULP )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgrqts (integer M, integer P, integer N, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, complex*16, dimension( lda, * ) Q, complex*16,
       dimension( lda, * ) R, integer LDA, complex*16, dimension( * ) TAUA, complex*16,
       dimension( ldb, * ) B, complex*16, dimension( ldb, * ) BF, complex*16, dimension( ldb, * )
       Z, complex*16, dimension( ldb, * ) T, complex*16, dimension( ldb, * ) BWK, integer LDB,
       complex*16, dimension( * ) TAUB, complex*16, dimension( lwork ) WORK, integer LWORK,
       double precision, dimension( * ) RWORK, double precision, dimension( 4 ) RESULT)
       ZGRQTS

       Purpose:

            ZGRQTS tests ZGGRQF, which computes the GRQ factorization of an
            M-by-N matrix A and a P-by-N matrix B: A = R*Q and B = Z*T*Q.

       Parameters:
           M

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

           P

                     P is INTEGER
                     The number of rows of the matrix B.  P >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrices A and B.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The M-by-N matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the GRQ factorization of A and B, as returned
                     by ZGGRQF, see CGGRQF for further details.

           Q

                     Q is COMPLEX*16 array, dimension (LDA,N)
                     The N-by-N unitary matrix Q.

           R

                     R is COMPLEX*16 array, dimension (LDA,MAX(M,N))

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, R and Q.
                     LDA >= max(M,N).

           TAUA

                     TAUA is COMPLEX*16 array, dimension (min(M,N))
                     The scalar factors of the elementary reflectors, as returned
                     by DGGQRC.

           B

                     B is COMPLEX*16 array, dimension (LDB,N)
                     On entry, the P-by-N matrix A.

           BF

                     BF is COMPLEX*16 array, dimension (LDB,N)
                     Details of the GQR factorization of A and B, as returned
                     by ZGGRQF, see CGGRQF for further details.

           Z

                     Z is DOUBLE PRECISION array, dimension (LDB,P)
                     The P-by-P unitary matrix Z.

           T

                     T is COMPLEX*16 array, dimension (LDB,max(P,N))

           BWK

                     BWK is COMPLEX*16 array, dimension (LDB,N)

           LDB

                     LDB is INTEGER
                     The leading dimension of the arrays B, BF, Z and T.
                     LDB >= max(P,N).

           TAUB

                     TAUB is COMPLEX*16 array, dimension (min(P,N))
                     The scalar factors of the elementary reflectors, as returned
                     by DGGRQF.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK, LWORK >= max(M,P,N)**2.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (4)
                     The test ratios:
                       RESULT(1) = norm( R - A*Q' ) / ( MAX(M,N)*norm(A)*ULP)
                       RESULT(2) = norm( T*Q - Z'*B ) / (MAX(P,N)*norm(B)*ULP)
                       RESULT(3) = norm( I - Q'*Q ) / ( N*ULP )
                       RESULT(4) = norm( I - Z'*Z ) / ( P*ULP )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zgsvts3 (integer M, integer P, integer N, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( ldb, * ) B,
       complex*16, dimension( ldb, * ) BF, integer LDB, complex*16, dimension( ldu, * ) U,
       integer LDU, complex*16, dimension( ldv, * ) V, integer LDV, complex*16, dimension( ldq, *
       ) Q, integer LDQ, double precision, dimension( * ) ALPHA, double precision, dimension( * )
       BETA, complex*16, dimension( ldr, * ) R, integer LDR, integer, dimension( * ) IWORK,
       complex*16, dimension( lwork ) WORK, integer LWORK, double precision, dimension( * )
       RWORK, double precision, dimension( 6 ) RESULT)
       ZGSVTS3

       Purpose:

            ZGSVTS3 tests ZGGSVD3, which computes the GSVD of an M-by-N matrix A
            and a P-by-N matrix B:
                         U'*A*Q = D1*R and V'*B*Q = D2*R.

       Parameters:
           M

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

           P

                     P is INTEGER
                     The number of rows of the matrix B.  P >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrices A and B.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,M)
                     The M-by-N matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)
                     Details of the GSVD of A and B, as returned by ZGGSVD3,
                     see ZGGSVD3 for further details.

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A and AF.
                     LDA >= max( 1,M ).

           B

                     B is COMPLEX*16 array, dimension (LDB,P)
                     On entry, the P-by-N matrix B.

           BF

                     BF is COMPLEX*16 array, dimension (LDB,N)
                     Details of the GSVD of A and B, as returned by ZGGSVD3,
                     see ZGGSVD3 for further details.

           LDB

                     LDB is INTEGER
                     The leading dimension of the arrays B and BF.
                     LDB >= max(1,P).

           U

                     U is COMPLEX*16 array, dimension(LDU,M)
                     The M by M unitary matrix U.

           LDU

                     LDU is INTEGER
                     The leading dimension of the array U. LDU >= max(1,M).

           V

                     V is COMPLEX*16 array, dimension(LDV,M)
                     The P by P unitary matrix V.

           LDV

                     LDV is INTEGER
                     The leading dimension of the array V. LDV >= max(1,P).

           Q

                     Q is COMPLEX*16 array, dimension(LDQ,N)
                     The N by N unitary matrix Q.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q. LDQ >= max(1,N).

           ALPHA

                     ALPHA is DOUBLE PRECISION array, dimension (N)

           BETA

                     BETA is DOUBLE PRECISION array, dimension (N)

                     The generalized singular value pairs of A and B, the
                     ``diagonal'' matrices D1 and D2 are constructed from
                     ALPHA and BETA, see subroutine ZGGSVD3 for details.

           R

                     R is COMPLEX*16 array, dimension(LDQ,N)
                     The upper triangular matrix R.

           LDR

                     LDR is INTEGER
                     The leading dimension of the array R. LDR >= max(1,N).

           IWORK

                     IWORK is INTEGER array, dimension (N)

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK,
                     LWORK >= max(M,P,N)*max(M,P,N).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(M,P,N))

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (6)
                     The test ratios:
                     RESULT(1) = norm( U'*A*Q - D1*R ) / ( MAX(M,N)*norm(A)*ULP)
                     RESULT(2) = norm( V'*B*Q - D2*R ) / ( MAX(P,N)*norm(B)*ULP)
                     RESULT(3) = norm( I - U'*U ) / ( M*ULP )
                     RESULT(4) = norm( I - V'*V ) / ( P*ULP )
                     RESULT(5) = norm( I - Q'*Q ) / ( N*ULP )
                     RESULT(6) = 0        if ALPHA is in decreasing order;
                               = ULPINV   otherwise.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           August 2015

   subroutine zhbt21 (character UPLO, integer N, integer KA, integer KS, complex*16, dimension(
       lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision, dimension(
       * ) E, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( * ) WORK,
       double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
       ZHBT21

       Purpose:

            ZHBT21  generally checks a decomposition of the form

                    A = U S UC>
            where * means conjugate transpose, A is hermitian banded, U is
            unitary, and S is diagonal (if KS=0) or symmetric
            tridiagonal (if KS=1).

            Specifically:

                    RESULT(1) = | A - U S U* | / ( |A| n ulp ) *andC>         RESULT(2) = | I - UU* | / ( n ulp )

       Parameters:
           UPLO

                     UPLO is CHARACTER
                     If UPLO='U', the upper triangle of A and V will be used and
                     the (strictly) lower triangle will not be referenced.
                     If UPLO='L', the lower triangle of A and V will be used and
                     the (strictly) upper triangle will not be referenced.

           N

                     N is INTEGER
                     The size of the matrix.  If it is zero, ZHBT21 does nothing.
                     It must be at least zero.

           KA

                     KA is INTEGER
                     The bandwidth of the matrix A.  It must be at least zero.  If
                     it is larger than N-1, then max( 0, N-1 ) will be used.

           KS

                     KS is INTEGER
                     The bandwidth of the matrix S.  It may only be zero or one.
                     If zero, then S is diagonal, and E is not referenced.  If
                     one, then S is symmetric tri-diagonal.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The original (unfactored) matrix.  It is assumed to be
                     hermitian, and only the upper (UPLO='U') or only the lower
                     (UPLO='L') will be referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at least 1
                     and at least min( KA, N-1 ).

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The diagonal of the (symmetric tri-) diagonal matrix S.

           E

                     E is DOUBLE PRECISION array, dimension (N-1)
                     The off-diagonal of the (symmetric tri-) diagonal matrix S.
                     E(1) is the (1,2) and (2,1) element, E(2) is the (2,3) and
                     (3,2) element, etc.
                     Not referenced if KS=0.

           U

                     U is COMPLEX*16 array, dimension (LDU, N)
                     The unitary matrix in the decomposition, expressed as a
                     dense matrix (i.e., not as a product of Householder
                     transformations, Givens transformations, etc.)

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  LDU must be at least N and
                     at least 1.

           WORK

                     WORK is COMPLEX*16 array, dimension (N**2)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the two tests described above.  The
                     values are currently limited to 1/ulp, to avoid overflow.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zhet21 (integer ITYPE, character UPLO, integer N, integer KBAND, complex*16,
       dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double precision,
       dimension( * ) E, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension(
       ldv, * ) V, integer LDV, complex*16, dimension( * ) TAU, complex*16, dimension( * ) WORK,
       double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
       ZHET21

       Purpose:

            ZHET21 generally checks a decomposition of the form

               A = U S UC>
            where * means conjugate transpose, A is hermitian, U is unitary, and
            S is diagonal (if KBAND=0) or (real) symmetric tridiagonal (if
            KBAND=1).

            If ITYPE=1, then U is represented as a dense matrix; otherwise U is
            expressed as a product of Householder transformations, whose vectors
            are stored in the array "V" and whose scaling constants are in "TAU".
            We shall use the letter "V" to refer to the product of Householder
            transformations (which should be equal to U).

            Specifically, if ITYPE=1, then:

               RESULT(1) = | A - U S U* | / ( |A| n ulp ) *andC>    RESULT(2) = | I - UU* | / ( n ulp )

            If ITYPE=2, then:

               RESULT(1) = | A - V S V* | / ( |A| n ulp )

            If ITYPE=3, then:

               RESULT(1) = | I - UV* | / ( n ulp )

            For ITYPE > 1, the transformation U is expressed as a product
            V = H(1)...H(n-2),  where H(j) = I  -  tau(j) v(j) v(j)C> and each
            vector v(j) has its first j elements 0 and the remaining n-j elements
            stored in V(j+1:n,j).

       Parameters:
           ITYPE

                     ITYPE is INTEGER
                     Specifies the type of tests to be performed.
                     1: U expressed as a dense unitary matrix:
                        RESULT(1) = | A - U S U* | / ( |A| n ulp )   *andC>             RESULT(2) = | I - UU* | / ( n ulp )

                     2: U expressed as a product V of Housholder transformations:
                        RESULT(1) = | A - V S V* | / ( |A| n ulp )

                     3: U expressed both as a dense unitary matrix and
                        as a product of Housholder transformations:
                        RESULT(1) = | I - UV* | / ( n ulp )

           UPLO

                     UPLO is CHARACTER
                     If UPLO='U', the upper triangle of A and V will be used and
                     the (strictly) lower triangle will not be referenced.
                     If UPLO='L', the lower triangle of A and V will be used and
                     the (strictly) upper triangle will not be referenced.

           N

                     N is INTEGER
                     The size of the matrix.  If it is zero, ZHET21 does nothing.
                     It must be at least zero.

           KBAND

                     KBAND is INTEGER
                     The bandwidth of the matrix.  It may only be zero or one.
                     If zero, then S is diagonal, and E is not referenced.  If
                     one, then S is symmetric tri-diagonal.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The original (unfactored) matrix.  It is assumed to be
                     hermitian, and only the upper (UPLO='U') or only the lower
                     (UPLO='L') will be referenced.

           LDA

                     LDA is INTEGER
                     The leading dimension of A.  It must be at least 1
                     and at least N.

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The diagonal of the (symmetric tri-) diagonal matrix.

           E

                     E is DOUBLE PRECISION array, dimension (N-1)
                     The off-diagonal of the (symmetric tri-) diagonal matrix.
                     E(1) is the (1,2) and (2,1) element, E(2) is the (2,3) and
                     (3,2) element, etc.
                     Not referenced if KBAND=0.

           U

                     U is COMPLEX*16 array, dimension (LDU, N)
                     If ITYPE=1 or 3, this contains the unitary matrix in
                     the decomposition, expressed as a dense matrix.  If ITYPE=2,
                     then it is not referenced.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  LDU must be at least N and
                     at least 1.

           V

                     V is COMPLEX*16 array, dimension (LDV, N)
                     If ITYPE=2 or 3, the columns of this array contain the
                     Householder vectors used to describe the unitary matrix
                     in the decomposition.  If UPLO='L', then the vectors are in
                     the lower triangle, if UPLO='U', then in the upper
                     triangle.
                     *NOTE* If ITYPE=2 or 3, V is modified and restored.  The
                     subdiagonal (if UPLO='L') or the superdiagonal (if UPLO='U')
                     is set to one, and later reset to its original value, during
                     the course of the calculation.
                     If ITYPE=1, then it is neither referenced nor modified.

           LDV

                     LDV is INTEGER
                     The leading dimension of V.  LDV must be at least N and
                     at least 1.

           TAU

                     TAU is COMPLEX*16 array, dimension (N)
                     If ITYPE >= 2, then TAU(j) is the scalar factor of
                     v(j) v(j)* in the Householder transformation H(j) of
                     the product  U = H(1)...H(n-2)
                     If ITYPE < 2, then TAU is not referenced.

           WORK

                     WORK is COMPLEX*16 array, dimension (2*N**2)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the two tests described above.  The
                     values are currently limited to 1/ulp, to avoid overflow.
                     RESULT(1) is always modified.  RESULT(2) is modified only
                     if ITYPE=1.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zhet22 (integer ITYPE, character UPLO, integer N, integer M, integer KBAND,
       complex*16, dimension( lda, * ) A, integer LDA, double precision, dimension( * ) D, double
       precision, dimension( * ) E, complex*16, dimension( ldu, * ) U, integer LDU, complex*16,
       dimension( ldv, * ) V, integer LDV, complex*16, dimension( * ) TAU, complex*16, dimension(
       * ) WORK, double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
       ZHET22

       Purpose:

                 ZHET22  generally checks a decomposition of the form

                         A U = U S

                 where A is complex Hermitian, the columns of U are orthonormal,
                 and S is diagonal (if KBAND=0) or symmetric tridiagonal (if
                 KBAND=1).  If ITYPE=1, then U is represented as a dense matrix,
                 otherwise the U is expressed as a product of Householder
                 transformations, whose vectors are stored in the array "V" and
                 whose scaling constants are in "TAU"; we shall use the letter
                 "V" to refer to the product of Householder transformations
                 (which should be equal to U).

                 Specifically, if ITYPE=1, then:

                         RESULT(1) = | U' A U - S | / ( |A| m ulp ) *andC>              RESULT(2) = | I - U'U | / ( m ulp )

             ITYPE   INTEGER
                     Specifies the type of tests to be performed.
                     1: U expressed as a dense orthogonal matrix:
                        RESULT(1) = | A - U S U' | / ( |A| n ulp )   *andC>             RESULT(2) = | I - UU' | / ( n ulp )

             UPLO    CHARACTER
                     If UPLO='U', the upper triangle of A will be used and the
                     (strictly) lower triangle will not be referenced.  If
                     UPLO='L', the lower triangle of A will be used and the
                     (strictly) upper triangle will not be referenced.
                     Not modified.

             N       INTEGER
                     The size of the matrix.  If it is zero, ZHET22 does nothing.
                     It must be at least zero.
                     Not modified.

             M       INTEGER
                     The number of columns of U.  If it is zero, ZHET22 does
                     nothing.  It must be at least zero.
                     Not modified.

             KBAND   INTEGER
                     The bandwidth of the matrix.  It may only be zero or one.
                     If zero, then S is diagonal, and E is not referenced.  If
                     one, then S is symmetric tri-diagonal.
                     Not modified.

             A       COMPLEX*16 array, dimension (LDA , N)
                     The original (unfactored) matrix.  It is assumed to be
                     symmetric, and only the upper (UPLO='U') or only the lower
                     (UPLO='L') will be referenced.
                     Not modified.

             LDA     INTEGER
                     The leading dimension of A.  It must be at least 1
                     and at least N.
                     Not modified.

             D       DOUBLE PRECISION array, dimension (N)
                     The diagonal of the (symmetric tri-) diagonal matrix.
                     Not modified.

             E       DOUBLE PRECISION array, dimension (N)
                     The off-diagonal of the (symmetric tri-) diagonal matrix.
                     E(1) is ignored, E(2) is the (1,2) and (2,1) element, etc.
                     Not referenced if KBAND=0.
                     Not modified.

             U       COMPLEX*16 array, dimension (LDU, N)
                     If ITYPE=1, this contains the orthogonal matrix in
                     the decomposition, expressed as a dense matrix.
                     Not modified.

             LDU     INTEGER
                     The leading dimension of U.  LDU must be at least N and
                     at least 1.
                     Not modified.

             V       COMPLEX*16 array, dimension (LDV, N)
                     If ITYPE=2 or 3, the lower triangle of this array contains
                     the Householder vectors used to describe the orthogonal
                     matrix in the decomposition.  If ITYPE=1, then it is not
                     referenced.
                     Not modified.

             LDV     INTEGER
                     The leading dimension of V.  LDV must be at least N and
                     at least 1.
                     Not modified.

             TAU     COMPLEX*16 array, dimension (N)
                     If ITYPE >= 2, then TAU(j) is the scalar factor of
                     v(j) v(j)' in the Householder transformation H(j) of
                     the product  U = H(1)...H(n-2)
                     If ITYPE < 2, then TAU is not referenced.
                     Not modified.

             WORK    COMPLEX*16 array, dimension (2*N**2)
                     Workspace.
                     Modified.

             RWORK   DOUBLE PRECISION array, dimension (N)
                     Workspace.
                     Modified.

             RESULT  DOUBLE PRECISION array, dimension (2)
                     The values computed by the two tests described above.  The
                     values are currently limited to 1/ulp, to avoid overflow.
                     RESULT(1) is always modified.  RESULT(2) is modified only
                     if LDU is at least N.
                     Modified.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zhpt21 (integer ITYPE, character UPLO, integer N, integer KBAND, complex*16,
       dimension( * ) AP, double precision, dimension( * ) D, double precision, dimension( * ) E,
       complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( * ) VP, complex*16,
       dimension( * ) TAU, complex*16, dimension( * ) WORK, double precision, dimension( * )
       RWORK, double precision, dimension( 2 ) RESULT)
       ZHPT21

       Purpose:

            ZHPT21  generally checks a decomposition of the form

                    A = U S UC>
            where * means conjugate transpose, A is hermitian, U is
            unitary, and S is diagonal (if KBAND=0) or (real) symmetric
            tridiagonal (if KBAND=1).  If ITYPE=1, then U is represented as
            a dense matrix, otherwise the U is expressed as a product of
            Householder transformations, whose vectors are stored in the
            array "V" and whose scaling constants are in "TAU"; we shall
            use the letter "V" to refer to the product of Householder
            transformations (which should be equal to U).

            Specifically, if ITYPE=1, then:

                    RESULT(1) = | A - U S U* | / ( |A| n ulp ) *andC>         RESULT(2) = | I - UU* | / ( n ulp )

            If ITYPE=2, then:

                    RESULT(1) = | A - V S V* | / ( |A| n ulp )

            If ITYPE=3, then:

                    RESULT(1) = | I - UV* | / ( n ulp )

            Packed storage means that, for example, if UPLO='U', then the columns
            of the upper triangle of A are stored one after another, so that
            A(1,j+1) immediately follows A(j,j) in the array AP.  Similarly, if
            UPLO='L', then the columns of the lower triangle of A are stored one
            after another in AP, so that A(j+1,j+1) immediately follows A(n,j)
            in the array AP.  This means that A(i,j) is stored in:

               AP( i + j*(j-1)/2 )                 if UPLO='U'

               AP( i + (2*n-j)*(j-1)/2 )           if UPLO='L'

            The array VP bears the same relation to the matrix V that A does to
            AP.

            For ITYPE > 1, the transformation U is expressed as a product
            of Householder transformations:

               If UPLO='U', then  V = H(n-1)...H(1),  where

                   H(j) = I  -  tau(j) v(j) v(j)C>
               and the first j-1 elements of v(j) are stored in V(1:j-1,j+1),
               (i.e., VP( j*(j+1)/2 + 1 : j*(j+1)/2 + j-1 ) ),
               the j-th element is 1, and the last n-j elements are 0.

               If UPLO='L', then  V = H(1)...H(n-1),  where

                   H(j) = I  -  tau(j) v(j) v(j)C>
               and the first j elements of v(j) are 0, the (j+1)-st is 1, and the
               (j+2)-nd through n-th elements are stored in V(j+2:n,j) (i.e.,
               in VP( (2*n-j)*(j-1)/2 + j+2 : (2*n-j)*(j-1)/2 + n ) .)

       Parameters:
           ITYPE

                     ITYPE is INTEGER
                     Specifies the type of tests to be performed.
                     1: U expressed as a dense unitary matrix:
                        RESULT(1) = | A - U S U* | / ( |A| n ulp )   *andC>             RESULT(2) = | I - UU* | / ( n ulp )

                     2: U expressed as a product V of Housholder transformations:
                        RESULT(1) = | A - V S V* | / ( |A| n ulp )

                     3: U expressed both as a dense unitary matrix and
                        as a product of Housholder transformations:
                        RESULT(1) = | I - UV* | / ( n ulp )

           UPLO

                     UPLO is CHARACTER
                     If UPLO='U', the upper triangle of A and V will be used and
                     the (strictly) lower triangle will not be referenced.
                     If UPLO='L', the lower triangle of A and V will be used and
                     the (strictly) upper triangle will not be referenced.

           N

                     N is INTEGER
                     The size of the matrix.  If it is zero, ZHPT21 does nothing.
                     It must be at least zero.

           KBAND

                     KBAND is INTEGER
                     The bandwidth of the matrix.  It may only be zero or one.
                     If zero, then S is diagonal, and E is not referenced.  If
                     one, then S is symmetric tri-diagonal.

           AP

                     AP is COMPLEX*16 array, dimension (N*(N+1)/2)
                     The original (unfactored) matrix.  It is assumed to be
                     hermitian, and contains the columns of just the upper
                     triangle (UPLO='U') or only the lower triangle (UPLO='L'),
                     packed one after another.

           D

                     D is DOUBLE PRECISION array, dimension (N)
                     The diagonal of the (symmetric tri-) diagonal matrix.

           E

                     E is DOUBLE PRECISION array, dimension (N)
                     The off-diagonal of the (symmetric tri-) diagonal matrix.
                     E(1) is the (1,2) and (2,1) element, E(2) is the (2,3) and
                     (3,2) element, etc.
                     Not referenced if KBAND=0.

           U

                     U is COMPLEX*16 array, dimension (LDU, N)
                     If ITYPE=1 or 3, this contains the unitary matrix in
                     the decomposition, expressed as a dense matrix.  If ITYPE=2,
                     then it is not referenced.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  LDU must be at least N and
                     at least 1.

           VP

                     VP is DOUBLE PRECISION array, dimension (N*(N+1)/2)
                     If ITYPE=2 or 3, the columns of this array contain the
                     Householder vectors used to describe the unitary matrix
                     in the decomposition, as described in purpose.
                     *NOTE* If ITYPE=2 or 3, V is modified and restored.  The
                     subdiagonal (if UPLO='L') or the superdiagonal (if UPLO='U')
                     is set to one, and later reset to its original value, during
                     the course of the calculation.
                     If ITYPE=1, then it is neither referenced nor modified.

           TAU

                     TAU is COMPLEX*16 array, dimension (N)
                     If ITYPE >= 2, then TAU(j) is the scalar factor of
                     v(j) v(j)* in the Householder transformation H(j) of
                     the product  U = H(1)...H(n-2)
                     If ITYPE < 2, then TAU is not referenced.

           WORK

                     WORK is COMPLEX*16 array, dimension (N**2)
                     Workspace.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)
                     Workspace.

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the two tests described above.  The
                     values are currently limited to 1/ulp, to avoid overflow.
                     RESULT(1) is always modified.  RESULT(2) is modified only
                     if ITYPE=1.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zhst01 (integer N, integer ILO, integer IHI, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldh, * ) H, integer LDH, complex*16, dimension( ldq, *
       ) Q, integer LDQ, complex*16, dimension( lwork ) WORK, integer LWORK, double precision,
       dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
       ZHST01

       Purpose:

            ZHST01 tests the reduction of a general matrix A to upper Hessenberg
            form:  A = Q*H*Q'.  Two test ratios are computed;

            RESULT(1) = norm( A - Q*H*Q' ) / ( norm(A) * N * EPS )
            RESULT(2) = norm( I - Q'*Q ) / ( N * EPS )

            The matrix Q is assumed to be given explicitly as it would be
            following ZGEHRD + ZUNGHR.

            In this version, ILO and IHI are not used, but they could be used
            to save some work if this is desired.

       Parameters:
           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           ILO

                     ILO is INTEGER

           IHI

                     IHI is INTEGER

                     A is assumed to be upper triangular in rows and columns
                     1:ILO-1 and IHI+1:N, so Q differs from the identity only in
                     rows and columns ILO+1:IHI.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The original n by n matrix A.

           LDA

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

           H

                     H is COMPLEX*16 array, dimension (LDH,N)
                     The upper Hessenberg matrix H from the reduction A = Q*H*Q'
                     as computed by ZGEHRD.  H is assumed to be zero below the
                     first subdiagonal.

           LDH

                     LDH is INTEGER
                     The leading dimension of the array H.  LDH >= max(1,N).

           Q

                     Q is COMPLEX*16 array, dimension (LDQ,N)
                     The orthogonal matrix Q from the reduction A = Q*H*Q' as
                     computed by ZGEHRD + ZUNGHR.

           LDQ

                     LDQ is INTEGER
                     The leading dimension of the array Q.  LDQ >= max(1,N).

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  LWORK >= 2*N*N.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     RESULT(1) = norm( A - Q*H*Q' ) / ( norm(A) * N * EPS )
                     RESULT(2) = norm( I - Q'*Q ) / ( N * EPS )

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlarfy (character UPLO, integer N, complex*16, dimension( * ) V, integer INCV,
       complex*16 TAU, complex*16, dimension( ldc, * ) C, integer LDC, complex*16, dimension( * )
       WORK)
       ZLARFY

       Purpose:

            ZLARFY applies an elementary reflector, or Householder matrix, H,
            to an n x n Hermitian matrix C, from both the left and the right.

            H is represented in the form

               H = I - tau * v * v'

            where  tau  is a scalar and  v  is a vector.

            If  tau  is  zero, then  H  is taken to be the unit matrix.

       Parameters:
           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the upper or lower triangular part of the
                     Hermitian matrix C is stored.
                     = 'U':  Upper triangle
                     = 'L':  Lower triangle

           N

                     N is INTEGER
                     The number of rows and columns of the matrix C.  N >= 0.

           V

                     V is COMPLEX*16 array, dimension
                             (1 + (N-1)*abs(INCV))
                     The vector v as described above.

           INCV

                     INCV is INTEGER
                     The increment between successive elements of v.  INCV must
                     not be zero.

           TAU

                     TAU is COMPLEX*16
                     The value tau as described above.

           C

                     C is COMPLEX*16 array, dimension (LDC, N)
                     On entry, the matrix C.
                     On exit, C is overwritten by H * C * H'.

           LDC

                     LDC is INTEGER
                     The leading dimension of the array C.  LDC >= max( 1, N ).

           WORK

                     WORK is COMPLEX*16 array, dimension (N)

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlarhs (character*3 PATH, character XTYPE, character UPLO, character TRANS, integer
       M, integer N, integer KL, integer KU, integer NRHS, complex*16, dimension( lda, * ) A,
       integer LDA, complex*16, dimension( ldx, * ) X, integer LDX, complex*16, dimension( ldb, *
       ) B, integer LDB, integer, dimension( 4 ) ISEED, integer INFO)
       ZLARHS

       Purpose:

            ZLARHS chooses a set of NRHS random solution vectors and sets
            up the right hand sides for the linear system
               op( A ) * X = B,
            where op( A ) may be A, A**T (transpose of A), or A**H (conjugate
            transpose of A).

       Parameters:
           PATH

                     PATH is CHARACTER*3
                     The type of the complex matrix A.  PATH may be given in any
                     combination of upper and lower case.  Valid paths include
                        xGE:  General m x n matrix
                        xGB:  General banded matrix
                        xPO:  Hermitian positive definite, 2-D storage
                        xPP:  Hermitian positive definite packed
                        xPB:  Hermitian positive definite banded
                        xHE:  Hermitian indefinite, 2-D storage
                        xHP:  Hermitian indefinite packed
                        xHB:  Hermitian indefinite banded
                        xSY:  Symmetric indefinite, 2-D storage
                        xSP:  Symmetric indefinite packed
                        xSB:  Symmetric indefinite banded
                        xTR:  Triangular
                        xTP:  Triangular packed
                        xTB:  Triangular banded
                        xQR:  General m x n matrix
                        xLQ:  General m x n matrix
                        xQL:  General m x n matrix
                        xRQ:  General m x n matrix
                     where the leading character indicates the precision.

           XTYPE

                     XTYPE is CHARACTER*1
                     Specifies how the exact solution X will be determined:
                     = 'N':  New solution; generate a random X.
                     = 'C':  Computed; use value of X on entry.

           UPLO

                     UPLO is CHARACTER*1
                     Used only if A is symmetric or triangular; specifies whether
                     the upper or lower triangular part of the matrix A is stored.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           TRANS

                     TRANS is CHARACTER*1
                     Used only if A is nonsymmetric; specifies the operation
                     applied to the matrix A.
                     = 'N':  B := A    * X
                     = 'T':  B := A**T * X
                     = 'C':  B := A**H * X

           M

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

           N

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

           KL

                     KL is INTEGER
                     Used only if A is a band matrix; specifies the number of
                     subdiagonals of A if A is a general band matrix or if A is
                     symmetric or triangular and UPLO = 'L'; specifies the number
                     of superdiagonals of A if A is symmetric or triangular and
                     UPLO = 'U'.  0 <= KL <= M-1.

           KU

                     KU is INTEGER
                     Used only if A is a general band matrix or if A is
                     triangular.

                     If PATH = xGB, specifies the number of superdiagonals of A,
                     and 0 <= KU <= N-1.

                     If PATH = xTR, xTP, or xTB, specifies whether or not the
                     matrix has unit diagonal:
                     = 1:  matrix has non-unit diagonal (default)
                     = 2:  matrix has unit diagonal

           NRHS

                     NRHS is INTEGER
                     The number of right hand side vectors in the system A*X = B.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The test matrix whose type is given by PATH.

           LDA

                     LDA is INTEGER
                     The leading dimension of the array A.
                     If PATH = xGB, LDA >= KL+KU+1.
                     If PATH = xPB, xSB, xHB, or xTB, LDA >= KL+1.
                     Otherwise, LDA >= max(1,M).

           X

                     X is or output) COMPLEX*16 array, dimension (LDX,NRHS)
                     On entry, if XTYPE = 'C' (for 'Computed'), then X contains
                     the exact solution to the system of linear equations.
                     On exit, if XTYPE = 'N' (for 'New'), then X is initialized
                     with random values.

           LDX

                     LDX is INTEGER
                     The leading dimension of the array X.  If TRANS = 'N',
                     LDX >= max(1,N); if TRANS = 'T', LDX >= max(1,M).

           B

                     B is COMPLEX*16 array, dimension (LDB,NRHS)
                     The right hand side vector(s) for the system of equations,
                     computed from B = op(A) * X, where op(A) is determined by
                     TRANS.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  If TRANS = 'N',
                     LDB >= max(1,M); if TRANS = 'T', LDB >= max(1,N).

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     The seed vector for the random number generator (used in
                     ZLATMS).  Modified on exit.

           INFO

                     INFO is INTEGER
                     = 0:  successful exit
                     < 0:  if INFO = -i, the i-th argument had an illegal value

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlatm4 (integer ITYPE, integer N, integer NZ1, integer NZ2, logical RSIGN, double
       precision AMAGN, double precision RCOND, double precision TRIANG, integer IDIST, integer,
       dimension( 4 ) ISEED, complex*16, dimension( lda, * ) A, integer LDA)
       ZLATM4

       Purpose:

            ZLATM4 generates basic square matrices, which may later be
            multiplied by others in order to produce test matrices.  It is
            intended mainly to be used to test the generalized eigenvalue
            routines.

            It first generates the diagonal and (possibly) subdiagonal,
            according to the value of ITYPE, NZ1, NZ2, RSIGN, AMAGN, and RCOND.
            It then fills in the upper triangle with random numbers, if TRIANG is
            non-zero.

       Parameters:
           ITYPE

                     ITYPE is INTEGER
                     The "type" of matrix on the diagonal and sub-diagonal.
                     If ITYPE < 0, then type abs(ITYPE) is generated and then
                        swapped end for end (A(I,J) := A'(N-J,N-I).)  See also
                        the description of AMAGN and RSIGN.

                     Special types:
                     = 0:  the zero matrix.
                     = 1:  the identity.
                     = 2:  a transposed Jordan block.
                     = 3:  If N is odd, then a k+1 x k+1 transposed Jordan block
                           followed by a k x k identity block, where k=(N-1)/2.
                           If N is even, then k=(N-2)/2, and a zero diagonal entry
                           is tacked onto the end.

                     Diagonal types.  The diagonal consists of NZ1 zeros, then
                        k=N-NZ1-NZ2 nonzeros.  The subdiagonal is zero.  ITYPE
                        specifies the nonzero diagonal entries as follows:
                     = 4:  1, ..., k
                     = 5:  1, RCOND, ..., RCOND
                     = 6:  1, ..., 1, RCOND
                     = 7:  1, a, a^2, ..., a^(k-1)=RCOND
                     = 8:  1, 1-d, 1-2*d, ..., 1-(k-1)*d=RCOND
                     = 9:  random numbers chosen from (RCOND,1)
                     = 10: random numbers with distribution IDIST (see ZLARND.)

           N

                     N is INTEGER
                     The order of the matrix.

           NZ1

                     NZ1 is INTEGER
                     If abs(ITYPE) > 3, then the first NZ1 diagonal entries will
                     be zero.

           NZ2

                     NZ2 is INTEGER
                     If abs(ITYPE) > 3, then the last NZ2 diagonal entries will
                     be zero.

           RSIGN

                     RSIGN is LOGICAL
                     = .TRUE.:  The diagonal and subdiagonal entries will be
                                multiplied by random numbers of magnitude 1.
                     = .FALSE.: The diagonal and subdiagonal entries will be
                                left as they are (usually non-negative real.)

           AMAGN

                     AMAGN is DOUBLE PRECISION
                     The diagonal and subdiagonal entries will be multiplied by
                     AMAGN.

           RCOND

                     RCOND is DOUBLE PRECISION
                     If abs(ITYPE) > 4, then the smallest diagonal entry will be
                     RCOND.  RCOND must be between 0 and 1.

           TRIANG

                     TRIANG is DOUBLE PRECISION
                     The entries above the diagonal will be random numbers with
                     magnitude bounded by TRIANG (i.e., random numbers multiplied
                     by TRIANG.)

           IDIST

                     IDIST is INTEGER
                     On entry, DIST specifies the type of distribution to be used
                     to generate a random matrix .
                     = 1: real and imaginary parts each UNIFORM( 0, 1 )
                     = 2: real and imaginary parts each UNIFORM( -1, 1 )
                     = 3: real and imaginary parts each NORMAL( 0, 1 )
                     = 4: complex number uniform in DISK( 0, 1 )

           ISEED

                     ISEED is INTEGER array, dimension (4)
                     On entry ISEED specifies the seed of the random number
                     generator.  The values of ISEED are changed on exit, and can
                     be used in the next call to ZLATM4 to continue the same
                     random number sequence.
                     Note: ISEED(4) should be odd, for the random number generator
                     used at present.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     Array to be computed.

           LDA

                     LDA is INTEGER
                     Leading dimension of A.  Must be at least 1 and at least N.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   logical function zlctes (complex*16 Z, complex*16 D)
       ZLCTES

       Purpose:

            ZLCTES returns .TRUE. if the eigenvalue Z/D is to be selected
            (specifically, in this subroutine, if the real part of the
            eigenvalue is negative), and otherwise it returns .FALSE..

            It is used by the test routine ZDRGES to test whether the driver
            routine ZGGES successfully sorts eigenvalues.

       Parameters:
           Z

                     Z is COMPLEX*16
                     The numerator part of a complex eigenvalue Z/D.

           D

                     D is COMPLEX*16
                     The denominator part of a complex eigenvalue Z/D.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   logical function zlctsx (complex*16 ALPHA, complex*16 BETA)
       ZLCTSX

       Purpose:

            This function is used to determine what eigenvalues will be
            selected.  If this is part of the test driver ZDRGSX, do not
            change the code UNLESS you are testing input examples and not
            using the built-in examples.

       Parameters:
           ALPHA

                     ALPHA is COMPLEX*16

           BETA

                     BETA is COMPLEX*16

                     parameters to decide whether the pair (ALPHA, BETA) is
                     selected.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zlsets (integer M, integer P, integer N, complex*16, dimension( lda, * ) A,
       complex*16, dimension( lda, * ) AF, integer LDA, complex*16, dimension( ldb, * ) B,
       complex*16, dimension( ldb, * ) BF, integer LDB, complex*16, dimension( * ) C, complex*16,
       dimension( * ) CF, complex*16, dimension( * ) D, complex*16, dimension( * ) DF,
       complex*16, dimension( * ) X, complex*16, dimension( lwork ) WORK, integer LWORK, double
       precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
       ZLSETS

       Purpose:

            ZLSETS tests ZGGLSE - a subroutine for solving linear equality
            constrained least square problem (LSE).

       Parameters:
           M

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

           P

                     P is INTEGER
                     The number of rows of the matrix B.  P >= 0.

           N

                     N is INTEGER
                     The number of columns of the matrices A and B.  N >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA,N)
                     The M-by-N matrix A.

           AF

                     AF is COMPLEX*16 array, dimension (LDA,N)

           LDA

                     LDA is INTEGER
                     The leading dimension of the arrays A, AF, Q and R.
                     LDA >= max(M,N).

           B

                     B is COMPLEX*16 array, dimension (LDB,N)
                     The P-by-N matrix A.

           BF

                     BF is COMPLEX*16 array, dimension (LDB,N)

           LDB

                     LDB is INTEGER
                     The leading dimension of the arrays B, BF, V and S.
                     LDB >= max(P,N).

           C

                     C is COMPLEX*16 array, dimension( M )
                     the vector C in the LSE problem.

           CF

                     CF is COMPLEX*16 array, dimension( M )

           D

                     D is COMPLEX*16 array, dimension( P )
                     the vector D in the LSE problem.

           DF

                     DF is COMPLEX*16 array, dimension( P )

           X

                     X is COMPLEX*16 array, dimension( N )
                     solution vector X in the LSE problem.

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The dimension of the array WORK.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (M)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The test ratios:
                       RESULT(1) = norm( A*x - c )/ norm(A)*norm(X)*EPS
                       RESULT(2) = norm( B*x - d )/ norm(B)*norm(X)*EPS

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zsbmv (character UPLO, integer N, integer K, complex*16 ALPHA, complex*16,
       dimension( lda, * ) A, integer LDA, complex*16, dimension( * ) X, integer INCX, complex*16
       BETA, complex*16, dimension( * ) Y, integer INCY)
       ZSBMV

       Purpose:

            ZSBMV  performs the matrix-vector  operation

               y := alpha*A*x + beta*y,

            where alpha and beta are scalars, x and y are n element vectors and
            A is an n by n symmetric band matrix, with k super-diagonals.

             UPLO   - CHARACTER*1
                      On entry, UPLO specifies whether the upper or lower
                      triangular part of the band matrix A is being supplied as
                      follows:

                         UPLO = 'U' or 'u'   The upper triangular part of A is
                                             being supplied.

                         UPLO = 'L' or 'l'   The lower triangular part of A is
                                             being supplied.

                      Unchanged on exit.

             N      - INTEGER
                      On entry, N specifies the order of the matrix A.
                      N must be at least zero.
                      Unchanged on exit.

             K      - INTEGER
                      On entry, K specifies the number of super-diagonals of the
                      matrix A. K must satisfy  0 .le. K.
                      Unchanged on exit.

             ALPHA  - COMPLEX*16
                      On entry, ALPHA specifies the scalar alpha.
                      Unchanged on exit.

             A      - COMPLEX*16 array, dimension( LDA, N )
                      Before entry with UPLO = 'U' or 'u', the leading ( k + 1 )
                      by n part of the array A must contain the upper triangular
                      band part of the symmetric matrix, supplied column by
                      column, with the leading diagonal of the matrix in row
                      ( k + 1 ) of the array, the first super-diagonal starting at
                      position 2 in row k, and so on. The top left k by k triangle
                      of the array A is not referenced.
                      The following program segment will transfer the upper
                      triangular part of a symmetric band matrix from conventional
                      full matrix storage to band storage:

                            DO 20, J = 1, N
                               M = K + 1 - J
                               DO 10, I = MAX( 1, J - K ), J
                                  A( M + I, J ) = matrix( I, J )
                         10    CONTINUE
                         20 CONTINUE

                      Before entry with UPLO = 'L' or 'l', the leading ( k + 1 )
                      by n part of the array A must contain the lower triangular
                      band part of the symmetric matrix, supplied column by
                      column, with the leading diagonal of the matrix in row 1 of
                      the array, the first sub-diagonal starting at position 1 in
                      row 2, and so on. The bottom right k by k triangle of the
                      array A is not referenced.
                      The following program segment will transfer the lower
                      triangular part of a symmetric band matrix from conventional
                      full matrix storage to band storage:

                            DO 20, J = 1, N
                               M = 1 - J
                               DO 10, I = J, MIN( N, J + K )
                                  A( M + I, J ) = matrix( I, J )
                         10    CONTINUE
                         20 CONTINUE

                      Unchanged on exit.

             LDA    - INTEGER
                      On entry, LDA specifies the first dimension of A as declared
                      in the calling (sub) program. LDA must be at least
                      ( k + 1 ).
                      Unchanged on exit.

             X      - COMPLEX*16 array, dimension at least
                      ( 1 + ( N - 1 )*abs( INCX ) ).
                      Before entry, the incremented array X must contain the
                      vector x.
                      Unchanged on exit.

             INCX   - INTEGER
                      On entry, INCX specifies the increment for the elements of
                      X. INCX must not be zero.
                      Unchanged on exit.

             BETA   - COMPLEX*16
                      On entry, BETA specifies the scalar beta.
                      Unchanged on exit.

             Y      - COMPLEX*16 array, dimension at least
                      ( 1 + ( N - 1 )*abs( INCY ) ).
                      Before entry, the incremented array Y must contain the
                      vector y. On exit, Y is overwritten by the updated vector y.

             INCY   - INTEGER
                      On entry, INCY specifies the increment for the elements of
                      Y. INCY must not be zero.
                      Unchanged on exit.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zsgt01 (integer ITYPE, character UPLO, integer N, integer M, complex*16, dimension(
       lda, * ) A, integer LDA, complex*16, dimension( ldb, * ) B, integer LDB, complex*16,
       dimension( ldz, * ) Z, integer LDZ, double precision, dimension( * ) D, complex*16,
       dimension( * ) WORK, double precision, dimension( * ) RWORK, double precision, dimension(
       * ) RESULT)
       ZSGT01

       Purpose:

            CDGT01 checks a decomposition of the form

               A Z   =  B Z D or
               A B Z =  Z D or
               B A Z =  Z D

            where A is a Hermitian matrix, B is Hermitian positive definite,
            Z is unitary, and D is diagonal.

            One of the following test ratios is computed:

            ITYPE = 1:  RESULT(1) = | A Z - B Z D | / ( |A| |Z| n ulp )

            ITYPE = 2:  RESULT(1) = | A B Z - Z D | / ( |A| |Z| n ulp )

            ITYPE = 3:  RESULT(1) = | B A Z - Z D | / ( |A| |Z| n ulp )

       Parameters:
           ITYPE

                     ITYPE is INTEGER
                     The form of the Hermitian generalized eigenproblem.
                     = 1:  A*z = (lambda)*B*z
                     = 2:  A*B*z = (lambda)*z
                     = 3:  B*A*z = (lambda)*z

           UPLO

                     UPLO is CHARACTER*1
                     Specifies whether the upper or lower triangular part of the
                     Hermitian matrices A and B is stored.
                     = 'U':  Upper triangular
                     = 'L':  Lower triangular

           N

                     N is INTEGER
                     The order of the matrix A.  N >= 0.

           M

                     M is INTEGER
                     The number of eigenvalues found.  M >= 0.

           A

                     A is COMPLEX*16 array, dimension (LDA, N)
                     The original Hermitian matrix A.

           LDA

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

           B

                     B is COMPLEX*16 array, dimension (LDB, N)
                     The original Hermitian positive definite matrix B.

           LDB

                     LDB is INTEGER
                     The leading dimension of the array B.  LDB >= max(1,N).

           Z

                     Z is COMPLEX*16 array, dimension (LDZ, M)
                     The computed eigenvectors of the generalized eigenproblem.

           LDZ

                     LDZ is INTEGER
                     The leading dimension of the array Z.  LDZ >= max(1,N).

           D

                     D is DOUBLE PRECISION array, dimension (M)
                     The computed eigenvalues of the generalized eigenproblem.

           WORK

                     WORK is COMPLEX*16 array, dimension (N*N)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (1)
                     The test ratio as described above.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   logical function zslect (complex*16 Z)
       ZSLECT

       Purpose:

            ZSLECT returns .TRUE. if the eigenvalue Z is to be selected,
            otherwise it returns .FALSE.
            It is used by ZCHK41 to test if ZGEES successfully sorts eigenvalues,
            and by ZCHK43 to test if ZGEESX successfully sorts eigenvalues.

            The common block /SSLCT/ controls how eigenvalues are selected.
            If SELOPT = 0, then ZSLECT return .TRUE. when real(Z) is less than
            zero, and .FALSE. otherwise.
            If SELOPT is at least 1, ZSLECT returns SELVAL(SELOPT) and adds 1
            to SELOPT, cycling back to 1 at SELMAX.

       Parameters:
           Z

                     Z is COMPLEX*16
                     The eigenvalue Z.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zstt21 (integer N, integer KBAND, double precision, dimension( * ) AD, double
       precision, dimension( * ) AE, double precision, dimension( * ) SD, double precision,
       dimension( * ) SE, complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension(
       * ) WORK, double precision, dimension( * ) RWORK, double precision, dimension( 2 ) RESULT)
       ZSTT21

       Purpose:

            ZSTT21  checks a decomposition of the form

               A = U S UC>
            where * means conjugate transpose, A is real symmetric tridiagonal,
            U is unitary, and S is real and diagonal (if KBAND=0) or symmetric
            tridiagonal (if KBAND=1).  Two tests are performed:

               RESULT(1) = | A - U S U* | / ( |A| n ulp )

               RESULT(2) = | I - UU* | / ( n ulp )

       Parameters:
           N

                     N is INTEGER
                     The size of the matrix.  If it is zero, ZSTT21 does nothing.
                     It must be at least zero.

           KBAND

                     KBAND is INTEGER
                     The bandwidth of the matrix S.  It may only be zero or one.
                     If zero, then S is diagonal, and SE is not referenced.  If
                     one, then S is symmetric tri-diagonal.

           AD

                     AD is DOUBLE PRECISION array, dimension (N)
                     The diagonal of the original (unfactored) matrix A.  A is
                     assumed to be real symmetric tridiagonal.

           AE

                     AE is DOUBLE PRECISION array, dimension (N-1)
                     The off-diagonal of the original (unfactored) matrix A.  A
                     is assumed to be symmetric tridiagonal.  AE(1) is the (1,2)
                     and (2,1) element, AE(2) is the (2,3) and (3,2) element, etc.

           SD

                     SD is DOUBLE PRECISION array, dimension (N)
                     The diagonal of the real (symmetric tri-) diagonal matrix S.

           SE

                     SE is DOUBLE PRECISION array, dimension (N-1)
                     The off-diagonal of the (symmetric tri-) diagonal matrix S.
                     Not referenced if KBSND=0.  If KBAND=1, then AE(1) is the
                     (1,2) and (2,1) element, SE(2) is the (2,3) and (3,2)
                     element, etc.

           U

                     U is COMPLEX*16 array, dimension (LDU, N)
                     The unitary matrix in the decomposition.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  LDU must be at least N.

           WORK

                     WORK is COMPLEX*16 array, dimension (N**2)

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the two tests described above.  The
                     values are currently limited to 1/ulp, to avoid overflow.
                     RESULT(1) is always modified.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zstt22 (integer N, integer M, integer KBAND, double precision, dimension( * ) AD,
       double precision, dimension( * ) AE, double precision, dimension( * ) SD, double
       precision, dimension( * ) SE, complex*16, dimension( ldu, * ) U, integer LDU, complex*16,
       dimension( ldwork, * ) WORK, integer LDWORK, double precision, dimension( * ) RWORK,
       double precision, dimension( 2 ) RESULT)
       ZSTT22

       Purpose:

            ZSTT22  checks a set of M eigenvalues and eigenvectors,

                A U = U S

            where A is Hermitian tridiagonal, the columns of U are unitary,
            and S is diagonal (if KBAND=0) or Hermitian tridiagonal (if KBAND=1).
            Two tests are performed:

               RESULT(1) = | U* A U - S | / ( |A| m ulp )

               RESULT(2) = | I - U*U | / ( m ulp )

       Parameters:
           N

                     N is INTEGER
                     The size of the matrix.  If it is zero, ZSTT22 does nothing.
                     It must be at least zero.

           M

                     M is INTEGER
                     The number of eigenpairs to check.  If it is zero, ZSTT22
                     does nothing.  It must be at least zero.

           KBAND

                     KBAND is INTEGER
                     The bandwidth of the matrix S.  It may only be zero or one.
                     If zero, then S is diagonal, and SE is not referenced.  If
                     one, then S is Hermitian tri-diagonal.

           AD

                     AD is DOUBLE PRECISION array, dimension (N)
                     The diagonal of the original (unfactored) matrix A.  A is
                     assumed to be Hermitian tridiagonal.

           AE

                     AE is DOUBLE PRECISION array, dimension (N)
                     The off-diagonal of the original (unfactored) matrix A.  A
                     is assumed to be Hermitian tridiagonal.  AE(1) is ignored,
                     AE(2) is the (1,2) and (2,1) element, etc.

           SD

                     SD is DOUBLE PRECISION array, dimension (N)
                     The diagonal of the (Hermitian tri-) diagonal matrix S.

           SE

                     SE is DOUBLE PRECISION array, dimension (N)
                     The off-diagonal of the (Hermitian tri-) diagonal matrix S.
                     Not referenced if KBSND=0.  If KBAND=1, then AE(1) is
                     ignored, SE(2) is the (1,2) and (2,1) element, etc.

           U

                     U is DOUBLE PRECISION array, dimension (LDU, N)
                     The unitary matrix in the decomposition.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  LDU must be at least N.

           WORK

                     WORK is COMPLEX*16 array, dimension (LDWORK, M+1)

           LDWORK

                     LDWORK is INTEGER
                     The leading dimension of WORK.  LDWORK must be at least
                     max(1,M).

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (N)

           RESULT

                     RESULT is DOUBLE PRECISION array, dimension (2)
                     The values computed by the two tests described above.  The
                     values are currently limited to 1/ulp, to avoid overflow.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zunt01 (character ROWCOL, integer M, integer N, complex*16, dimension( ldu, * ) U,
       integer LDU, complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension(
       * ) RWORK, double precision RESID)
       ZUNT01

       Purpose:

            ZUNT01 checks that the matrix U is unitary by computing the ratio

               RESID = norm( I - U*U' ) / ( n * EPS ), if ROWCOL = 'R',
            or
               RESID = norm( I - U'*U ) / ( m * EPS ), if ROWCOL = 'C'.

            Alternatively, if there isn't sufficient workspace to form
            I - U*U' or I - U'*U, the ratio is computed as

               RESID = abs( I - U*U' ) / ( n * EPS ), if ROWCOL = 'R',
            or
               RESID = abs( I - U'*U ) / ( m * EPS ), if ROWCOL = 'C'.

            where EPS is the machine precision.  ROWCOL is used only if m = n;
            if m > n, ROWCOL is assumed to be 'C', and if m < n, ROWCOL is
            assumed to be 'R'.

       Parameters:
           ROWCOL

                     ROWCOL is CHARACTER
                     Specifies whether the rows or columns of U should be checked
                     for orthogonality.  Used only if M = N.
                     = 'R':  Check for orthogonal rows of U
                     = 'C':  Check for orthogonal columns of U

           M

                     M is INTEGER
                     The number of rows of the matrix U.

           N

                     N is INTEGER
                     The number of columns of the matrix U.

           U

                     U is COMPLEX*16 array, dimension (LDU,N)
                     The unitary matrix U.  U is checked for orthogonal columns
                     if m > n or if m = n and ROWCOL = 'C'.  U is checked for
                     orthogonal rows if m < n or if m = n and ROWCOL = 'R'.

           LDU

                     LDU is INTEGER
                     The leading dimension of the array U.  LDU >= max(1,M).

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  For best performance, LWORK
                     should be at least N*N if ROWCOL = 'C' or M*M if
                     ROWCOL = 'R', but the test will be done even if LWORK is 0.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (min(M,N))
                     Used only if LWORK is large enough to use the Level 3 BLAS
                     code.

           RESID

                     RESID is DOUBLE PRECISION
                     RESID = norm( I - U * U' ) / ( n * EPS ), if ROWCOL = 'R', or
                     RESID = norm( I - U' * U ) / ( m * EPS ), if ROWCOL = 'C'.

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

   subroutine zunt03 (character*( * ) RC, integer MU, integer MV, integer N, integer K,
       complex*16, dimension( ldu, * ) U, integer LDU, complex*16, dimension( ldv, * ) V, integer
       LDV, complex*16, dimension( * ) WORK, integer LWORK, double precision, dimension( * )
       RWORK, double precision RESULT, integer INFO)
       ZUNT03

       Purpose:

            ZUNT03 compares two unitary matrices U and V to see if their
            corresponding rows or columns span the same spaces.  The rows are
            checked if RC = 'R', and the columns are checked if RC = 'C'.

            RESULT is the maximum of

               | V*V' - I | / ( MV ulp ), if RC = 'R', or

               | V'*V - I | / ( MV ulp ), if RC = 'C',

            and the maximum over rows (or columns) 1 to K of

               | U(i) - S*V(i) |/ ( N ulp )

            where abs(S) = 1 (chosen to minimize the expression), U(i) is the
            i-th row (column) of U, and V(i) is the i-th row (column) of V.

       Parameters:
           RC

                     RC is CHARACTER*1
                     If RC = 'R' the rows of U and V are to be compared.
                     If RC = 'C' the columns of U and V are to be compared.

           MU

                     MU is INTEGER
                     The number of rows of U if RC = 'R', and the number of
                     columns if RC = 'C'.  If MU = 0 ZUNT03 does nothing.
                     MU must be at least zero.

           MV

                     MV is INTEGER
                     The number of rows of V if RC = 'R', and the number of
                     columns if RC = 'C'.  If MV = 0 ZUNT03 does nothing.
                     MV must be at least zero.

           N

                     N is INTEGER
                     If RC = 'R', the number of columns in the matrices U and V,
                     and if RC = 'C', the number of rows in U and V.  If N = 0
                     ZUNT03 does nothing.  N must be at least zero.

           K

                     K is INTEGER
                     The number of rows or columns of U and V to compare.
                     0 <= K <= max(MU,MV).

           U

                     U is COMPLEX*16 array, dimension (LDU,N)
                     The first matrix to compare.  If RC = 'R', U is MU by N, and
                     if RC = 'C', U is N by MU.

           LDU

                     LDU is INTEGER
                     The leading dimension of U.  If RC = 'R', LDU >= max(1,MU),
                     and if RC = 'C', LDU >= max(1,N).

           V

                     V is COMPLEX*16 array, dimension (LDV,N)
                     The second matrix to compare.  If RC = 'R', V is MV by N, and
                     if RC = 'C', V is N by MV.

           LDV

                     LDV is INTEGER
                     The leading dimension of V.  If RC = 'R', LDV >= max(1,MV),
                     and if RC = 'C', LDV >= max(1,N).

           WORK

                     WORK is COMPLEX*16 array, dimension (LWORK)

           LWORK

                     LWORK is INTEGER
                     The length of the array WORK.  For best performance, LWORK
                     should be at least N*N if RC = 'C' or M*M if RC = 'R', but
                     the tests will be done even if LWORK is 0.

           RWORK

                     RWORK is DOUBLE PRECISION array, dimension (max(MV,N))

           RESULT

                     RESULT is DOUBLE PRECISION
                     The value computed by the test described above.  RESULT is
                     limited to 1/ulp to avoid overflow.

           INFO

                     INFO is INTEGER
                     0  indicates a successful exit
                     -k indicates the k-th parameter had an illegal value

       Author:
           Univ. of Tennessee

           Univ. of California Berkeley

           Univ. of Colorado Denver

           NAG Ltd.

       Date:
           November 2011

Author

       Generated automatically by Doxygen for LAPACK from the source code.