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

.in +1c
.ti -1c
.RI "subroutine \fBcchkhb\fP (nsizes, nn, nwdths, kk, ntypes, dotype, iseed, thresh, nounit, a, lda, sd, se, u, ldu, work, lwork, rwork, result, info)"
.br
.RI "\fBCCHKHB\fP "
.in -1c
.SH "Function/Subroutine Documentation"
.PP 
.SS "subroutine cchkhb (integer nsizes, integer, dimension( * ) nn, integer nwdths, integer, dimension( * ) kk, integer ntypes, logical, dimension( * ) dotype, integer, dimension( 4 ) iseed, real thresh, integer nounit, complex, dimension( lda, * ) a, integer lda, real, dimension( * ) sd, real, dimension( * ) se, complex, dimension( ldu, * ) u, integer ldu, complex, dimension( * ) work, integer lwork, real, dimension( * ) rwork, real, dimension( * ) result, integer info)"

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

.PP
.nf
!>
!> CCHKHB tests the reduction of a Hermitian band matrix to tridiagonal
!> from, used with the Hermitian eigenvalue problem\&.
!>
!> CHBTRD factors a Hermitian band matrix A as  U S U* , where * means
!> conjugate transpose, S is symmetric tridiagonal, and U is unitary\&.
!> CHBTRD can use either just the lower or just the upper triangle
!> of A; CCHKHB checks both cases\&.
!>
!> When CCHKHB is called, a number of matrix  (), a number
!> of bandwidths (), and a number of matrix  are
!> specified\&.  For each size (), each bandwidth () less than or
!> equal to , 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 CHBTRD with
!>                                         UPLO='U'
!>
!> (2)     | I - UU* | / ( n ulp )
!>
!> (3)     | A - V S V* | / ( |A| n ulp )  computed by CHBTRD with
!>                                         UPLO='L'
!>
!> (4)     | I - UU* | / ( n ulp )
!>
!> The  are specified by an array NN(1:NSIZES); the value of
!> each element NN(j) specifies one size\&.
!> The  are specified by a logical array DOTYPE( 1:NTYPES );
!> if DOTYPE(j) is \&.TRUE\&., then matrix type  will be generated\&.
!> Currently, the list of possible types is:
!>
!> (1)  The zero matrix\&.
!> (2)  The identity matrix\&.
!>
!> (3)  A 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  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  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 )
!> 
.fi
.PP
 
.RE
.PP
\fBParameters\fP
.RS 4
\fINSIZES\fP 
.PP
.nf
!>          NSIZES is INTEGER
!>          The number of sizes of matrices to use\&.  If it is zero,
!>          CCHKHB does nothing\&.  It must be at least zero\&.
!> 
.fi
.PP
.br
\fINN\fP 
.PP
.nf
!>          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\&.
!> 
.fi
.PP
.br
\fINWDTHS\fP 
.PP
.nf
!>          NWDTHS is INTEGER
!>          The number of bandwidths to use\&.  If it is zero,
!>          CCHKHB does nothing\&.  It must be at least zero\&.
!> 
.fi
.PP
.br
\fIKK\fP 
.PP
.nf
!>          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\&.
!> 
.fi
.PP
.br
\fINTYPES\fP 
.PP
.nf
!>          NTYPES is INTEGER
!>          The number of elements in DOTYPE\&.   If it is zero, CCHKHB
!>          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\&. \&.
!> 
.fi
.PP
.br
\fIDOTYPE\fP 
.PP
.nf
!>          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\&.
!> 
.fi
.PP
.br
\fIISEED\fP 
.PP
.nf
!>          ISEED is INTEGER array, dimension (4)
!>          On entry ISEED specifies the seed of the random number
!>          generator\&. The array elements should be between 0 and 4095;
!>          if not they will be reduced mod 4096\&.  Also, ISEED(4) must
!>          be odd\&.  The random number generator uses a linear
!>          congruential sequence limited to small integers, and so
!>          should produce machine independent random numbers\&. The
!>          values of ISEED are changed on exit, and can be used in the
!>          next call to CCHKHB to continue the same random number
!>          sequence\&.
!> 
.fi
.PP
.br
\fITHRESH\fP 
.PP
.nf
!>          THRESH is REAL
!>          A test will count as  if the , computed as
!>          described above, exceeds THRESH\&.  Note that the error
!>          is scaled to be O(1), so THRESH should be a reasonably
!>          small multiple of 1, e\&.g\&., 10 or 100\&.  In particular,
!>          it should not depend on the precision (single vs\&. double)
!>          or the size of the matrix\&.  It must be at least zero\&.
!> 
.fi
.PP
.br
\fINOUNIT\fP 
.PP
.nf
!>          NOUNIT is INTEGER
!>          The FORTRAN unit number for printing out error messages
!>          (e\&.g\&., if a routine returns IINFO not equal to 0\&.)
!> 
.fi
.PP
.br
\fIA\fP 
.PP
.nf
!>          A is COMPLEX array, dimension
!>                            (LDA, max(NN))
!>          Used to hold the matrix whose eigenvalues are to be
!>          computed\&.
!> 
.fi
.PP
.br
\fILDA\fP 
.PP
.nf
!>          LDA is INTEGER
!>          The leading dimension of A\&.  It must be at least 2 (not 1!)
!>          and at least max( KK )+1\&.
!> 
.fi
.PP
.br
\fISD\fP 
.PP
.nf
!>          SD is REAL array, dimension (max(NN))
!>          Used to hold the diagonal of the tridiagonal matrix computed
!>          by CHBTRD\&.
!> 
.fi
.PP
.br
\fISE\fP 
.PP
.nf
!>          SE is REAL array, dimension (max(NN))
!>          Used to hold the off-diagonal of the tridiagonal matrix
!>          computed by CHBTRD\&.
!> 
.fi
.PP
.br
\fIU\fP 
.PP
.nf
!>          U is COMPLEX array, dimension (LDU, max(NN))
!>          Used to hold the unitary matrix computed by CHBTRD\&.
!> 
.fi
.PP
.br
\fILDU\fP 
.PP
.nf
!>          LDU is INTEGER
!>          The leading dimension of U\&.  It must be at least 1
!>          and at least max( NN )\&.
!> 
.fi
.PP
.br
\fIWORK\fP 
.PP
.nf
!>          WORK is COMPLEX array, dimension (LWORK)
!> 
.fi
.PP
.br
\fILWORK\fP 
.PP
.nf
!>          LWORK is INTEGER
!>          The number of entries in WORK\&.  This must be at least
!>          max( LDA+1, max(NN)+1 )*max(NN)\&.
!> 
.fi
.PP
.br
\fIRWORK\fP 
.PP
.nf
!>          RWORK is REAL array
!> 
.fi
.PP
.br
\fIRESULT\fP 
.PP
.nf
!>          RESULT is REAL array, dimension (4)
!>          The values computed by the tests described above\&.
!>          The values are currently limited to 1/ulp, to avoid
!>          overflow\&.
!> 
.fi
.PP
.br
\fIINFO\fP 
.PP
.nf
!>          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 \&.
!>       KMODE(j)        The MODE value to be passed to the matrix
!>                       generator for type \&.
!>       KMAGN(j)        The order of magnitude ( O(1),
!>                       O(overflow^(1/2) ), O(underflow^(1/2) )
!> 
.fi
.PP
 
.RE
.PP
\fBAuthor\fP
.RS 4
Univ\&. of Tennessee 

.PP
Univ\&. of California Berkeley 

.PP
Univ\&. of Colorado Denver 

.PP
NAG Ltd\&. 
.RE
.PP

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