cchkaa.F

Go to the documentation of this file.

*> \brief \b CCHKAA
*
*  =========== DOCUMENTATION ===========
*
* Online html documentation available at
*            http://www.netlib.org/lapack/explore-html/
*
*  Definition:
*  ===========
*
*       PROGRAM CCHKAA
*
*
*> \par Purpose:
*  =============
*>
*> \verbatim
*>
*> CCHKAA is the main test program for the COMPLEX linear equation
*> routines.
*>
*> The program must be driven by a short data file. The first 15 records
*> (not including the first comment  line) specify problem dimensions
*> and program options using list-directed input. The remaining lines
*> specify the LAPACK test paths and the number of matrix types to use
*> in testing.  An annotated example of a data file can be obtained by
*> deleting the first 3 characters from the following 42 lines:
*> Data file for testing COMPLEX LAPACK linear equation routines
*> 7                      Number of values of M
*> 0 1 2 3 5 10 16        Values of M (row dimension)
*> 7                      Number of values of N
*> 0 1 2 3 5 10 16        Values of N (column dimension)
*> 1                      Number of values of NRHS
*> 2                      Values of NRHS (number of right hand sides)
*> 5                      Number of values of NB
*> 1 3 3 3 20             Values of NB (the blocksize)
*> 1 0 5 9 1              Values of NX (crossover point)
*> 3                      Number of values of RANK
*> 30 50 90               Values of rank (as a % of N)
*> 30.0                   Threshold value of test ratio
*> T                      Put T to test the LAPACK routines
*> T                      Put T to test the driver routines
*> T                      Put T to test the error exits
*> CGE   11               List types on next line if 0 < NTYPES < 11
*> CGB    8               List types on next line if 0 < NTYPES <  8
*> CGT   12               List types on next line if 0 < NTYPES < 12
*> CPO    9               List types on next line if 0 < NTYPES <  9
*> CPO    9               List types on next line if 0 < NTYPES <  9
*> CPP    9               List types on next line if 0 < NTYPES <  9
*> CPB    8               List types on next line if 0 < NTYPES <  8
*> CPT   12               List types on next line if 0 < NTYPES < 12
*> CHE   10               List types on next line if 0 < NTYPES < 10
*> CHR   10               List types on next line if 0 < NTYPES < 10
*> CHK   10               List types on next line if 0 < NTYPES < 10
*> CHA   10               List types on next line if 0 < NTYPES < 10
*> CH2   10               List types on next line if 0 < NTYPES < 10
*> CSA   11               List types on next line if 0 < NTYPES < 10
*> CS2   11               List types on next line if 0 < NTYPES < 10
*> CHP   10               List types on next line if 0 < NTYPES < 10
*> CSY   11               List types on next line if 0 < NTYPES < 11
*> CSK   11               List types on next line if 0 < NTYPES < 11
*> CSR   11               List types on next line if 0 < NTYPES < 11
*> CSP   11               List types on next line if 0 < NTYPES < 11
*> CTR   18               List types on next line if 0 < NTYPES < 18
*> CTP   18               List types on next line if 0 < NTYPES < 18
*> CTB   17               List types on next line if 0 < NTYPES < 17
*> CQR    8               List types on next line if 0 < NTYPES <  8
*> CRQ    8               List types on next line if 0 < NTYPES <  8
*> CLQ    8               List types on next line if 0 < NTYPES <  8
*> CQL    8               List types on next line if 0 < NTYPES <  8
*> CQP    6               List types on next line if 0 < NTYPES <  6
*> ZQK   19               List types on next line if 0 < NTYPES < 19
*> CTZ    3               List types on next line if 0 < NTYPES <  3
*> CLS    6               List types on next line if 0 < NTYPES <  6
*> CEQ
*> CQT
*> CQX
*> CTS
*> CHH
*> \endverbatim
*
*  Parameters:
*  ==========
*
*> \verbatim
*>  NMAX    INTEGER
*>          The maximum allowable value for M and N.
*>
*>  MAXIN   INTEGER
*>          The number of different values that can be used for each of
*>          M, N, NRHS, NB, NX and RANK
*>
*>  MAXRHS  INTEGER
*>          The maximum number of right hand sides
*>
*>  MATMAX  INTEGER
*>          The maximum number of matrix types to use for testing
*>
*>  NIN     INTEGER
*>          The unit number for input
*>
*>  NOUT    INTEGER
*>          The unit number for output
*> \endverbatim
*
*  Authors:
*  ========
*
*> \author Univ. of Tennessee
*> \author Univ. of California Berkeley
*> \author Univ. of Colorado Denver
*> \author NAG Ltd.
*
*> \ingroup complex_lin
*
*  =====================================================================
      PROGRAM cchkaa
*
*  -- LAPACK test routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*  =====================================================================
*
*     .. Parameters ..
      INTEGER            nmax
      parameter( nmax = 132 )
      INTEGER            maxin
      parameter( maxin = 12 )
      INTEGER            maxrhs
      parameter( maxrhs = 16 )
      INTEGER            matmax
      parameter( matmax = 30 )
      INTEGER            nin, nout
      parameter( nin = 5, nout = 6 )
      INTEGER            kdmax
      parameter( kdmax = nmax+( nmax+1 ) / 4 )
*     ..
*     .. Local Scalars ..
      LOGICAL            fatal, tstchk, tstdrv, tsterr
      CHARACTER          c1
      CHARACTER*2        c2
      CHARACTER*3        path
      CHARACTER*10       intstr
      CHARACTER*72       aline
      INTEGER            i, ic, j, k, la, lafac, lda, nb, nm, nmats, nn,
     $                   nnb, nnb2, nns, nrhs, ntypes, nrank,
     $                   vers_major, vers_minor, vers_patch
      REAL               eps, s1, s2, threq, thresh
*     ..
*     .. Local Arrays ..
      LOGICAL            dotype( matmax )
      INTEGER            iwork( 25*nmax ), mval( maxin ),
     $                   nbval( maxin ), nbval2( maxin ),
     $                   nsval( maxin ), nval( maxin ), nxval( maxin ),
     $                   rankval( maxin ), piv( nmax )
*     ..
*     .. Allocatable Arrays ..
      INTEGER allocatestatus
      REAL, DIMENSION(:), ALLOCATABLE :: rwork, s
      COMPLEX, DIMENSION(:), ALLOCATABLE :: e
      COMPLEX, DIMENSION(:,:), ALLOCATABLE :: a, b, work
*     ..
*     .. External Functions ..
      LOGICAL            lsame, lsamen
      REAL               second, slamch
      EXTERNAL           lsame, lsamen, second, slamch
*     ..
*     .. External Subroutines ..
      EXTERNAL           alareq, cchkeq, cchkgb, cchkge, cchkgt, cchkhe,
     $                   cchkhe_rook, cchkhe_rk, cchkhe_aa, cchkhp,
     $                   cchklq, cchkunhr_col, cchkpb, cchkpo, cchkps,
     $                   cchkpp, cchkpt, cchkq3, cchkqp3rk, cchkql,
     $                   cchkqr, cchkrq, cchksp, cchksy, cchksy_rook,
     $                   cchksy_rk, cchksy_aa, cchktb, cchktp, cchktr,
     $                   cchktz, cdrvgb, cdrvge, cdrvgt, cdrvhe,
     $                   cdrvhe_rook, cdrvhe_rk, cdrvhe_aa, cdrvhp,
     $                   cdrvls, cdrvpb, cdrvpo, cdrvpp, cdrvpt, cdrvsp,
     $                   cdrvsy, cdrvsy_rook, cdrvsy_rk, cdrvsy_aa,
     $                   ilaver, cchkqrt, cchkqrtp
*     ..
*     .. Scalars in Common ..
      LOGICAL            lerr, ok
      CHARACTER*32       srnamt
      INTEGER            infot, nunit
*     ..
*     .. Arrays in Common ..
      INTEGER            iparms( 100 )
*     ..
*     .. Common blocks ..
      COMMON             / claenv / iparms
      COMMON             / infoc / infot, nunit, ok, lerr
      COMMON             / srnamc / srnamt
*     ..
*     .. Data statements ..
      DATA               threq / 2.0 / , intstr / '0123456789' /
*     ..
*     .. Allocate memory dynamically ..
*
      ALLOCATE ( a( ( kdmax+1 )*nmax, 7 ), stat = allocatestatus )
      IF (allocatestatus /= 0) stop "*** Not enough memory ***"
      ALLOCATE ( b( nmax*maxrhs, 4 ), stat = allocatestatus )
      IF (allocatestatus /= 0) stop "*** Not enough memory ***"
      ALLOCATE ( work( nmax, nmax+maxrhs+10 ), stat = allocatestatus )
      IF (allocatestatus /= 0) stop "*** Not enough memory ***"
      ALLOCATE ( e( nmax ), stat = allocatestatus )
      IF (allocatestatus /= 0) stop "*** Not enough memory ***"
      ALLOCATE ( s( 2*nmax ), stat = allocatestatus)
      IF (allocatestatus /= 0) stop "*** Not enough memory ***"
      ALLOCATE ( rwork( 150*nmax+2*maxrhs ), stat = allocatestatus )
      IF (allocatestatus /= 0) stop "*** Not enough memory ***"
*     ..
*     .. Executable Statements ..
*
      s1 = second( )
      lda = nmax
      fatal = .false.
*
*     Read a dummy line.
*
      READ( nin, fmt = * )
*
*     Report values of parameters.
*
      CALL ilaver( vers_major, vers_minor, vers_patch )
      WRITE( nout, fmt = 9994 ) vers_major, vers_minor, vers_patch
*
*     Read the values of M
*
      READ( nin, fmt = * )nm
      IF( nm.LT.1 ) THEN
         WRITE( nout, fmt = 9996 )' NM ', nm, 1
         nm = 0
         fatal = .true.
      ELSE IF( nm.GT.maxin ) THEN
         WRITE( nout, fmt = 9995 )' NM ', nm, maxin
         nm = 0
         fatal = .true.
      END IF
      READ( nin, fmt = * )( mval( i ), i = 1, nm )
      DO 10 i = 1, nm
         IF( mval( i ).LT.0 ) THEN
            WRITE( nout, fmt = 9996 )' M  ', mval( i ), 0
            fatal = .true.
         ELSE IF( mval( i ).GT.nmax ) THEN
            WRITE( nout, fmt = 9995 )' M  ', mval( i ), nmax
            fatal = .true.
         END IF
   10 CONTINUE
      IF( nm.GT.0 )
     $   WRITE( nout, fmt = 9993 )'M   ', ( mval( i ), i = 1, nm )
*
*     Read the values of N
*
      READ( nin, fmt = * )nn
      IF( nn.LT.1 ) THEN
         WRITE( nout, fmt = 9996 )' NN ', nn, 1
         nn = 0
         fatal = .true.
      ELSE IF( nn.GT.maxin ) THEN
         WRITE( nout, fmt = 9995 )' NN ', nn, maxin
         nn = 0
         fatal = .true.
      END IF
      READ( nin, fmt = * )( nval( i ), i = 1, nn )
      DO 20 i = 1, nn
         IF( nval( i ).LT.0 ) THEN
            WRITE( nout, fmt = 9996 )' N  ', nval( i ), 0
            fatal = .true.
         ELSE IF( nval( i ).GT.nmax ) THEN
            WRITE( nout, fmt = 9995 )' N  ', nval( i ), nmax
            fatal = .true.
         END IF
   20 CONTINUE
      IF( nn.GT.0 )
     $   WRITE( nout, fmt = 9993 )'N   ', ( nval( i ), i = 1, nn )
*
*     Read the values of NRHS
*
      READ( nin, fmt = * )nns
      IF( nns.LT.1 ) THEN
         WRITE( nout, fmt = 9996 )' NNS', nns, 1
         nns = 0
         fatal = .true.
      ELSE IF( nns.GT.maxin ) THEN
         WRITE( nout, fmt = 9995 )' NNS', nns, maxin
         nns = 0
         fatal = .true.
      END IF
      READ( nin, fmt = * )( nsval( i ), i = 1, nns )
      DO 30 i = 1, nns
         IF( nsval( i ).LT.0 ) THEN
            WRITE( nout, fmt = 9996 )'NRHS', nsval( i ), 0
            fatal = .true.
         ELSE IF( nsval( i ).GT.maxrhs ) THEN
            WRITE( nout, fmt = 9995 )'NRHS', nsval( i ), maxrhs
            fatal = .true.
         END IF
   30 CONTINUE
      IF( nns.GT.0 )
     $   WRITE( nout, fmt = 9993 )'NRHS', ( nsval( i ), i = 1, nns )
*
*     Read the values of NB
*
      READ( nin, fmt = * )nnb
      IF( nnb.LT.1 ) THEN
         WRITE( nout, fmt = 9996 )'NNB ', nnb, 1
         nnb = 0
         fatal = .true.
      ELSE IF( nnb.GT.maxin ) THEN
         WRITE( nout, fmt = 9995 )'NNB ', nnb, maxin
         nnb = 0
         fatal = .true.
      END IF
      READ( nin, fmt = * )( nbval( i ), i = 1, nnb )
      DO 40 i = 1, nnb
         IF( nbval( i ).LT.0 ) THEN
            WRITE( nout, fmt = 9996 )' NB ', nbval( i ), 0
            fatal = .true.
         END IF
   40 CONTINUE
      IF( nnb.GT.0 )
     $   WRITE( nout, fmt = 9993 )'NB  ', ( nbval( i ), i = 1, nnb )
*
*     Set NBVAL2 to be the set of unique values of NB
*
      nnb2 = 0
      DO 60 i = 1, nnb
         nb = nbval( i )
         DO 50 j = 1, nnb2
            IF( nb.EQ.nbval2( j ) )
     $         GO TO 60
   50    CONTINUE
         nnb2 = nnb2 + 1
         nbval2( nnb2 ) = nb
   60 CONTINUE
*
*     Read the values of NX
*
      READ( nin, fmt = * )( nxval( i ), i = 1, nnb )
      DO 70 i = 1, nnb
         IF( nxval( i ).LT.0 ) THEN
            WRITE( nout, fmt = 9996 )' NX ', nxval( i ), 0
            fatal = .true.
         END IF
   70 CONTINUE
      IF( nnb.GT.0 )
     $   WRITE( nout, fmt = 9993 )'NX  ', ( nxval( i ), i = 1, nnb )
*
*     Read the values of RANKVAL
*
      READ( nin, fmt = * )nrank
      IF( nn.LT.1 ) THEN
         WRITE( nout, fmt = 9996 )' NRANK ', nrank, 1
         nrank = 0
         fatal = .true.
      ELSE IF( nn.GT.maxin ) THEN
         WRITE( nout, fmt = 9995 )' NRANK ', nrank, maxin
         nrank = 0
         fatal = .true.
      END IF
      READ( nin, fmt = * )( rankval( i ), i = 1, nrank )
      DO i = 1, nrank
         IF( rankval( i ).LT.0 ) THEN
            WRITE( nout, fmt = 9996 )' RANK  ', rankval( i ), 0
            fatal = .true.
         ELSE IF( rankval( i ).GT.100 ) THEN
            WRITE( nout, fmt = 9995 )' RANK  ', rankval( i ), 100
            fatal = .true.
         END IF
      END DO
      IF( nrank.GT.0 )
     $   WRITE( nout, fmt = 9993 )'RANK % OF N',
     $   ( rankval( i ), i = 1, nrank )
*
*     Read the threshold value for the test ratios.
*
      READ( nin, fmt = * )thresh
      WRITE( nout, fmt = 9992 )thresh
*
*     Read the flag that indicates whether to test the LAPACK routines.
*
      READ( nin, fmt = * )tstchk
*
*     Read the flag that indicates whether to test the driver routines.
*
      READ( nin, fmt = * )tstdrv
*
*     Read the flag that indicates whether to test the error exits.
*
      READ( nin, fmt = * )tsterr
*
      IF( fatal ) THEN
         WRITE( nout, fmt = 9999 )
         stop
      END IF
*
*     Calculate and print the machine dependent constants.
*
      eps = slamch( 'Underflow threshold' )
      WRITE( nout, fmt = 9991 )'underflow', eps
      eps = slamch( 'Overflow threshold' )
      WRITE( nout, fmt = 9991 )'overflow ', eps
      eps = slamch( 'Epsilon' )
      WRITE( nout, fmt = 9991 )'precision', eps
      WRITE( nout, fmt = * )
      nrhs = nsval( 1 )
*
   80 CONTINUE
*
*     Read a test path and the number of matrix types to use.
*
      READ( nin, fmt = '(A72)', END = 140 )aline
      path = aline( 1: 3 )
      nmats = matmax
      i = 3
   90 CONTINUE
      i = i + 1
      IF( i.GT.72 )
     $   GO TO 130
      IF( aline( i: i ).EQ.' ' )
     $   GO TO 90
      nmats = 0
  100 CONTINUE
      c1 = aline( i: i )
      DO 110 k = 1, 10
         IF( c1.EQ.intstr( k: k ) ) THEN
            ic = k - 1
            GO TO 120
         END IF
  110 CONTINUE
      GO TO 130
  120 CONTINUE
      nmats = nmats*10 + ic
      i = i + 1
      IF( i.GT.72 )
     $   GO TO 130
      GO TO 100
  130 CONTINUE
      c1 = path( 1: 1 )
      c2 = path( 2: 3 )
*
*     Check first character for correct precision.
*
      IF( .NOT.lsame( c1, 'Complex precision' ) ) THEN
         WRITE( nout, fmt = 9990 )path
*
      ELSE IF( nmats.LE.0 ) THEN
*
*        Check for a positive number of tests requested.
*
         WRITE( nout, fmt = 9989 )path
*
      ELSE IF( lsamen( 2, c2, 'GE' ) ) THEN
*
*        GE:  general matrices
*
         ntypes = 11
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkge( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
     $                   nsval, thresh, tsterr, lda, a( 1, 1 ),
     $                   a( 1, 2 ), a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
     $                   b( 1, 3 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvge( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
     $                   rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'GB' ) ) THEN
*
*        GB:  general banded matrices
*
         la = ( 2*kdmax+1 )*nmax
         lafac = ( 3*kdmax+1 )*nmax
         ntypes = 8
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkgb( dotype, nm, mval, nn, nval, nnb2, nbval2, nns,
     $                   nsval, thresh, tsterr, a( 1, 1 ), la,
     $                   a( 1, 3 ), lafac, b( 1, 1 ), b( 1, 2 ),
     $                   b( 1, 3 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvgb( dotype, nn, nval, nrhs, thresh, tsterr,
     $                   a( 1, 1 ), la, a( 1, 3 ), lafac, a( 1, 6 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s,
     $                   work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'GT' ) ) THEN
*
*        GT:  general tridiagonal matrices
*
         ntypes = 12
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkgt( dotype, nn, nval, nns, nsval, thresh, tsterr,
     $                   a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
     $                   b( 1, 3 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvgt( dotype, nn, nval, nrhs, thresh, tsterr,
     $                   a( 1, 1 ), a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
     $                   b( 1, 3 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'PO' ) ) THEN
*
*        PO:  positive definite matrices
*
         ntypes = 9
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkpo( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                   thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                   a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                   work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvpo( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
     $                   rwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'PS' ) ) THEN
*
*        PS:  positive semi-definite matrices
*
         ntypes = 9
*
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkps( dotype, nn, nval, nnb2, nbval2, nrank,
     $                   rankval, thresh, tsterr, lda, a( 1, 1 ),
     $                   a( 1, 2 ), a( 1, 3 ), piv, work, rwork,
     $                   nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'PP' ) ) THEN
*
*        PP:  positive definite packed matrices
*
         ntypes = 9
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkpp( dotype, nn, nval, nns, nsval, thresh, tsterr,
     $                   lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
     $                   nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvpp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
     $                   rwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'PB' ) ) THEN
*
*        PB:  positive definite banded matrices
*
         ntypes = 8
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkpb( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                   thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                   a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                   work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvpb( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), b( 1, 4 ), s, work,
     $                   rwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'PT' ) ) THEN
*
*        PT:  positive definite tridiagonal matrices
*
         ntypes = 12
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkpt( dotype, nn, nval, nns, nsval, thresh, tsterr,
     $                   a( 1, 1 ), s, a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
     $                   b( 1, 3 ), work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvpt( dotype, nn, nval, nrhs, thresh, tsterr,
     $                   a( 1, 1 ), s, a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
     $                   b( 1, 3 ), work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'HE' ) ) THEN
*
*        HE:  Hermitian indefinite matrices,
*             with partial (Bunch-Kaufman) pivoting algorithm
*
         ntypes = 10
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkhe( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                   thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                   a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                   work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvhe( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
     $                   nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'HR' ) ) THEN
*
*        HR:  Hermitian indefinite matrices,
*             with bounded Bunch-Kaufman (rook) pivoting algorithm
*
         ntypes = 10
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkhe_rook(dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                       thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                       a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                       work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvhe_rook( dotype, nn, nval, nrhs, thresh, tsterr,
     $                        lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                        b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
     $                        rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'HK' ) ) THEN
*
*        HK:  Hermitian indefinite matrices,
*             with bounded Bunch-Kaufman (rook) pivoting algorithm,
*             different matrix storage format than HR path version.
*
         ntypes = 10
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkhe_rk( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                      thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                      e, a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
     $                      b( 1, 3 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvhe_rk( dotype, nn, nval, nrhs, thresh, tsterr,
     $                      lda, a( 1, 1 ), a( 1, 2 ), e, a( 1, 3 ),
     $                      b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
     $                      rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'HA' ) ) THEN
*
*        HA:  Hermitian matrices,
*             Aasen Algorithm
*
         ntypes = 10
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkhe_aa( dotype, nn, nval, nnb2, nbval2, nns,
     $                      nsval, thresh, tsterr, lda,
     $                      a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                      b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                      work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvhe_aa( dotype, nn, nval, nrhs, thresh, tsterr,
     $                      lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                           b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                      work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'H2' ) ) THEN
*
*        H2:  Hermitian matrices,
*             with partial (Aasen's) pivoting algorithm
*
         ntypes = 10
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkhe_aa_2stage( dotype, nn, nval, nnb2, nbval2,
     $                         nns, nsval, thresh, tsterr, lda,
     $                         a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                         b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                         work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvhe_aa_2stage(
     $                         dotype, nn, nval, nrhs, thresh, tsterr,
     $                         lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                              b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                         work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'HP' ) ) THEN
*
*        HP:  Hermitian indefinite packed matrices,
*             with partial (Bunch-Kaufman) pivoting algorithm
*
         ntypes = 10
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkhp( dotype, nn, nval, nns, nsval, thresh, tsterr,
     $                   lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
     $                   iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvhp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
     $                   nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'SY' ) ) THEN
*
*        SY:  symmetric indefinite matrices,
*             with partial (Bunch-Kaufman) pivoting algorithm
*
         ntypes = 11
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchksy( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                   thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                   a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                   work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvsy( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
     $                   nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'SR' ) ) THEN
*
*        SR:  symmetric indefinite matrices,
*             with bounded Bunch-Kaufman (rook) pivoting algorithm
*
         ntypes = 11
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchksy_rook(dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                       thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                       a( 1, 3 ), b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                       work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvsy_rook( dotype, nn, nval, nrhs, thresh, tsterr,
     $                        lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                        b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
     $                        rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'SK' ) ) THEN
*
*        SK:  symmetric indefinite matrices,
*             with bounded Bunch-Kaufman (rook) pivoting algorithm,
*             different matrix storage format than SR path version.
*
         ntypes = 11
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchksy_rk( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                      thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                      e, a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
     $                      b( 1, 3 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvsy_rk( dotype, nn, nval, nrhs, thresh, tsterr,
     $                      lda, a( 1, 1 ), a( 1, 2 ), e, a( 1, 3 ),
     $                      b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
     $                      rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'SA' ) ) THEN
*
*        SA:  symmetric indefinite matrices with Aasen's algorithm,
*
         ntypes = 11
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchksy_aa( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                      thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                      a( 1, 3 ), b( 1, 1 ), b( 1, 2 ),
     $                      b( 1, 3 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvsy_aa( dotype, nn, nval, nrhs, thresh, tsterr,
     $                      lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                      b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
     $                      rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'S2' ) ) THEN
*
*        S2:  symmetric indefinite matrices with Aasen's algorithm
*             2 stage
*
         ntypes = 11
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchksy_aa_2stage( dotype, nn, nval, nnb2, nbval2, nns,
     $                      nsval, thresh, tsterr, lda,
     $                      a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                      b( 1, 1 ), b( 1, 2 ), b( 1, 3 ),
     $                      work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvsy_aa_2stage(
     $                      dotype, nn, nval, nrhs, thresh, tsterr,
     $                      lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                      b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work,
     $                      rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'SP' ) ) THEN
*
*        SP:  symmetric indefinite packed matrices,
*             with partial (Bunch-Kaufman) pivoting algorithm
*
         ntypes = 11
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchksp( dotype, nn, nval, nns, nsval, thresh, tsterr,
     $                   lda, a( 1, 1 ), a( 1, 2 ), a( 1, 3 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
     $                   iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
         IF( tstdrv ) THEN
            CALL cdrvsp( dotype, nn, nval, nrhs, thresh, tsterr, lda,
     $                   a( 1, 1 ), a( 1, 2 ), a( 1, 3 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), work, rwork, iwork,
     $                   nout )
         ELSE
            WRITE( nout, fmt = 9988 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'TR' ) ) THEN
*
*        TR:  triangular matrices
*
         ntypes = 18
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchktr( dotype, nn, nval, nnb2, nbval2, nns, nsval,
     $                   thresh, tsterr, lda, a( 1, 1 ), a( 1, 2 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), work, rwork,
     $                   nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'TP' ) ) THEN
*
*        TP:  triangular packed matrices
*
         ntypes = 18
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchktp( dotype, nn, nval, nns, nsval, thresh, tsterr,
     $                   lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'TB' ) ) THEN
*
*        TB:  triangular banded matrices
*
         ntypes = 17
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchktb( dotype, nn, nval, nns, nsval, thresh, tsterr,
     $                   lda, a( 1, 1 ), a( 1, 2 ), b( 1, 1 ),
     $                   b( 1, 2 ), b( 1, 3 ), work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'QR' ) ) THEN
*
*        QR:  QR factorization
*
         ntypes = 8
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkqr( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
     $                   nrhs, thresh, tsterr, nmax, a( 1, 1 ),
     $                   a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
     $                   work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'LQ' ) ) THEN
*
*        LQ:  LQ factorization
*
         ntypes = 8
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchklq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
     $                   nrhs, thresh, tsterr, nmax, a( 1, 1 ),
     $                   a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
     $                   work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'QL' ) ) THEN
*
*        QL:  QL factorization
*
         ntypes = 8
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkql( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
     $                   nrhs, thresh, tsterr, nmax, a( 1, 1 ),
     $                   a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
     $                   work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'RQ' ) ) THEN
*
*        RQ:  RQ factorization
*
         ntypes = 8
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkrq( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
     $                   nrhs, thresh, tsterr, nmax, a( 1, 1 ),
     $                   a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
     $                   b( 1, 1 ), b( 1, 2 ), b( 1, 3 ), b( 1, 4 ),
     $                   work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'EQ' ) ) THEN
*
*        EQ:  Equilibration routines for general and positive definite
*             matrices (THREQ should be between 2 and 10)
*
         IF( tstchk ) THEN
            CALL cchkeq( threq, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'TZ' ) ) THEN
*
*        TZ:  Trapezoidal matrix
*
         ntypes = 3
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchktz( dotype, nm, mval, nn, nval, thresh, tsterr,
     $                   a( 1, 1 ), a( 1, 2 ), s( 1 ),
     $                   b( 1, 1 ), work, rwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'QP' ) ) THEN
*
*        QP:  QR factorization with pivoting
*
         ntypes = 6
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkq3( dotype, nm, mval, nn, nval, nnb, nbval, nxval,
     $                   thresh, a( 1, 1 ), a( 1, 2 ), s( 1 ),
     $                   b( 1, 1 ), work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'QK' ) ) THEN
*
*        QK: truncated QR factorization with pivoting
*
         ntypes = 19
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstchk ) THEN
            CALL cchkqp3rk( dotype, nm, mval, nn, nval, nns, nsval,
     $                   nnb, nbval, nxval, thresh, a( 1, 1 ),
     $                   a( 1, 2 ), b( 1, 1 ), b( 1, 2 ),
     $                   s( 1 ), b( 1, 4 ),
     $                   work, rwork, iwork, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'LS' ) ) THEN
*
*        LS:  Least squares drivers
*
         ntypes = 6
         CALL alareq( path, nmats, dotype, ntypes, nin, nout )
*
         IF( tstdrv ) THEN
            CALL cdrvls( dotype, nm, mval, nn, nval, nns, nsval, nnb,
     $                   nbval, nxval, thresh, tsterr, a( 1, 1 ),
     $                   a( 1, 2 ), a( 1, 3 ), a( 1, 4 ), a( 1, 5 ),
     $                   s( 1 ), s( nmax+1 ), nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'QT' ) ) THEN
*
*        QT:  QRT routines for general matrices
*
         IF( tstchk ) THEN
            CALL cchkqrt( thresh, tsterr, nm, mval, nn, nval, nnb,
     $                    nbval, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'QX' ) ) THEN
*
*        QX:  QRT routines for triangular-pentagonal matrices
*
         IF( tstchk ) THEN
            CALL cchkqrtp( thresh, tsterr, nm, mval, nn, nval, nnb,
     $                     nbval, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'TQ' ) ) THEN
*
*        TQ:  LQT routines for general matrices
*
         IF( tstchk ) THEN
            CALL cchklqt( thresh, tsterr, nm, mval, nn, nval, nnb,
     $                    nbval, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'XQ' ) ) THEN
*
*        XQ:  LQT routines for triangular-pentagonal matrices
*
         IF( tstchk ) THEN
            CALL cchklqtp( thresh, tsterr, nm, mval, nn, nval, nnb,
     $                     nbval, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'TS' ) ) THEN
*
*        TS:  QR routines for tall-skinny matrices
*
         IF( tstchk ) THEN
            CALL cchktsqr( thresh, tsterr, nm, mval, nn, nval, nnb,
     $                     nbval, nout )
         ELSE
            WRITE( nout, fmt = 9989 )path
         END IF
*
      ELSE IF( lsamen( 2, c2, 'HH' ) ) THEN
*
*        HH:  Householder reconstruction for tall-skinny matrices
*
         IF( tstchk ) THEN
            CALL cchkunhr_col( thresh, tsterr, nm, mval, nn, nval, nnb,
     $                         nbval, nout )
         ELSE
            WRITE( nout, fmt = 9989 ) path
         END IF
*
      ELSE
*
         WRITE( nout, fmt = 9990 )path
      END IF
*
*     Go back to get another input line.
*
      GO TO 80
*
*     Branch to this line when the last record is read.
*
  140 CONTINUE
      CLOSE ( nin )
      s2 = second( )
      WRITE( nout, fmt = 9998 )
      WRITE( nout, fmt = 9997 )s2 - s1
*
      DEALLOCATE (a, stat = allocatestatus)
      DEALLOCATE (b, stat = allocatestatus)
      DEALLOCATE (e, stat = allocatestatus)
      DEALLOCATE (s, stat = allocatestatus)
      DEALLOCATE (work, stat = allocatestatus)
      DEALLOCATE (rwork,  stat = allocatestatus)
*
 9999 FORMAT( / ' Execution not attempted due to input errors' )
 9998 FORMAT( / ' End of tests' )
 9997 FORMAT( ' Total time used = ', f12.2, ' seconds', / )
 9996 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be >=',
     $      i6 )
 9995 FORMAT( ' Invalid input value: ', a4, '=', i6, '; must be <=',
     $      i6 )
 9994 FORMAT( ' Tests of the COMPLEX LAPACK routines ',
     $      / ' LAPACK VERSION ', i1, '.', i1, '.', i1,
     $      / / ' The following parameter values will be used:' )
 9993 FORMAT( 4x, a4, ':  ', 10i6, / 11x, 10i6 )
 9992 FORMAT( / ' Routines pass computational tests if test ratio is ',
     $      'less than', f8.2, / )
 9991 FORMAT( ' Relative machine ', a, ' is taken to be', e16.6 )
 9990 FORMAT( / 1x, a3, ':  Unrecognized path name' )
 9989 FORMAT( / 1x, a3, ' routines were not tested' )
 9988 FORMAT( / 1x, a3, ' driver routines were not tested' )
*
*     End of CCHKAA
*
      END