LAPACK 3.3.1 Linear Algebra PACKage

# zlattb.f

Go to the documentation of this file.
```00001       SUBROUTINE ZLATTB( IMAT, UPLO, TRANS, DIAG, ISEED, N, KD, AB,
00002      \$                   LDAB, B, WORK, RWORK, INFO )
00003 *
00004 *  -- LAPACK test routine (version 3.1) --
00005 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
00006 *     November 2006
00007 *
00008 *     .. Scalar Arguments ..
00009       CHARACTER          DIAG, TRANS, UPLO
00010       INTEGER            IMAT, INFO, KD, LDAB, N
00011 *     ..
00012 *     .. Array Arguments ..
00013       INTEGER            ISEED( 4 )
00014       DOUBLE PRECISION   RWORK( * )
00015       COMPLEX*16         AB( LDAB, * ), B( * ), WORK( * )
00016 *     ..
00017 *
00018 *  Purpose
00019 *  =======
00020 *
00021 *  ZLATTB generates a triangular test matrix in 2-dimensional storage.
00022 *  IMAT and UPLO uniquely specify the properties of the test matrix,
00023 *  which is returned in the array A.
00024 *
00025 *  Arguments
00026 *  =========
00027 *
00028 *  IMAT    (input) INTEGER
00029 *          An integer key describing which matrix to generate for this
00030 *          path.
00031 *
00032 *  UPLO    (input) CHARACTER*1
00033 *          Specifies whether the matrix A will be upper or lower
00034 *          triangular.
00035 *          = 'U':  Upper triangular
00036 *          = 'L':  Lower triangular
00037 *
00038 *  TRANS   (input) CHARACTER*1
00039 *          Specifies whether the matrix or its transpose will be used.
00040 *          = 'N':  No transpose
00041 *          = 'T':  Transpose
00042 *          = 'C':  Conjugate transpose (= transpose)
00043 *
00044 *  DIAG    (output) CHARACTER*1
00045 *          Specifies whether or not the matrix A is unit triangular.
00046 *          = 'N':  Non-unit triangular
00047 *          = 'U':  Unit triangular
00048 *
00049 *  ISEED   (input/output) INTEGER array, dimension (4)
00050 *          The seed vector for the random number generator (used in
00051 *          ZLATMS).  Modified on exit.
00052 *
00053 *  N       (input) INTEGER
00054 *          The order of the matrix to be generated.
00055 *
00056 *  KD      (input) INTEGER
00057 *          The number of superdiagonals or subdiagonals of the banded
00058 *          triangular matrix A.  KD >= 0.
00059 *
00060 *  AB      (output) COMPLEX*16 array, dimension (LDAB,N)
00061 *          The upper or lower triangular banded matrix A, stored in the
00062 *          first KD+1 rows of AB.  Let j be a column of A, 1<=j<=n.
00063 *          If UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j.
00064 *          If UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+kd).
00065 *
00066 *  LDAB    (input) INTEGER
00067 *          The leading dimension of the array AB.  LDAB >= KD+1.
00068 *
00069 *  B       (workspace) COMPLEX*16 array, dimension (N)
00070 *
00071 *  WORK    (workspace) COMPLEX*16 array, dimension (2*N)
00072 *
00073 *  RWORK   (workspace) DOUBLE PRECISION array, dimension (N)
00074 *
00075 *  INFO    (output) INTEGER
00076 *          = 0:  successful exit
00077 *          < 0:  if INFO = -i, the i-th argument had an illegal value
00078 *
00079 *  =====================================================================
00080 *
00081 *     .. Parameters ..
00082       DOUBLE PRECISION   ONE, TWO, ZERO
00083       PARAMETER          ( ONE = 1.0D+0, TWO = 2.0D+0, ZERO = 0.0D+0 )
00084 *     ..
00085 *     .. Local Scalars ..
00086       LOGICAL            UPPER
00087       CHARACTER          DIST, PACKIT, TYPE
00088       CHARACTER*3        PATH
00089       INTEGER            I, IOFF, IY, J, JCOUNT, KL, KU, LENJ, MODE
00090       DOUBLE PRECISION   ANORM, BIGNUM, BNORM, BSCAL, CNDNUM, REXP,
00091      \$                   SFAC, SMLNUM, TEXP, TLEFT, TNORM, TSCAL, ULP,
00092      \$                   UNFL
00093       COMPLEX*16         PLUS1, PLUS2, STAR1
00094 *     ..
00095 *     .. External Functions ..
00096       LOGICAL            LSAME
00097       INTEGER            IZAMAX
00098       DOUBLE PRECISION   DLAMCH, DLARND
00099       COMPLEX*16         ZLARND
00100       EXTERNAL           LSAME, IZAMAX, DLAMCH, DLARND, ZLARND
00101 *     ..
00102 *     .. External Subroutines ..
00103       EXTERNAL           DLABAD, DLARNV, ZCOPY, ZDSCAL, ZLARNV, ZLATB4,
00104      \$                   ZLATMS, ZSWAP
00105 *     ..
00106 *     .. Intrinsic Functions ..
00107       INTRINSIC          ABS, DBLE, DCMPLX, MAX, MIN, SQRT
00108 *     ..
00109 *     .. Executable Statements ..
00110 *
00111       PATH( 1: 1 ) = 'Zomplex precision'
00112       PATH( 2: 3 ) = 'TB'
00113       UNFL = DLAMCH( 'Safe minimum' )
00114       ULP = DLAMCH( 'Epsilon' )*DLAMCH( 'Base' )
00115       SMLNUM = UNFL
00116       BIGNUM = ( ONE-ULP ) / SMLNUM
00117       CALL DLABAD( SMLNUM, BIGNUM )
00118       IF( ( IMAT.GE.6 .AND. IMAT.LE.9 ) .OR. IMAT.EQ.17 ) THEN
00119          DIAG = 'U'
00120       ELSE
00121          DIAG = 'N'
00122       END IF
00123       INFO = 0
00124 *
00125 *     Quick return if N.LE.0.
00126 *
00127       IF( N.LE.0 )
00128      \$   RETURN
00129 *
00130 *     Call ZLATB4 to set parameters for CLATMS.
00131 *
00132       UPPER = LSAME( UPLO, 'U' )
00133       IF( UPPER ) THEN
00134          CALL ZLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
00135      \$                CNDNUM, DIST )
00136          KU = KD
00137          IOFF = 1 + MAX( 0, KD-N+1 )
00138          KL = 0
00139          PACKIT = 'Q'
00140       ELSE
00141          CALL ZLATB4( PATH, -IMAT, N, N, TYPE, KL, KU, ANORM, MODE,
00142      \$                CNDNUM, DIST )
00143          KL = KD
00144          IOFF = 1
00145          KU = 0
00146          PACKIT = 'B'
00147       END IF
00148 *
00149 *     IMAT <= 5:  Non-unit triangular matrix
00150 *
00151       IF( IMAT.LE.5 ) THEN
00152          CALL ZLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, CNDNUM,
00153      \$                ANORM, KL, KU, PACKIT, AB( IOFF, 1 ), LDAB, WORK,
00154      \$                INFO )
00155 *
00156 *     IMAT > 5:  Unit triangular matrix
00157 *     The diagonal is deliberately set to something other than 1.
00158 *
00159 *     IMAT = 6:  Matrix is the identity
00160 *
00161       ELSE IF( IMAT.EQ.6 ) THEN
00162          IF( UPPER ) THEN
00163             DO 20 J = 1, N
00164                DO 10 I = MAX( 1, KD+2-J ), KD
00165                   AB( I, J ) = ZERO
00166    10          CONTINUE
00167                AB( KD+1, J ) = J
00168    20       CONTINUE
00169          ELSE
00170             DO 40 J = 1, N
00171                AB( 1, J ) = J
00172                DO 30 I = 2, MIN( KD+1, N-J+1 )
00173                   AB( I, J ) = ZERO
00174    30          CONTINUE
00175    40       CONTINUE
00176          END IF
00177 *
00178 *     IMAT > 6:  Non-trivial unit triangular matrix
00179 *
00180 *     A unit triangular matrix T with condition CNDNUM is formed.
00181 *     In this version, T only has bandwidth 2, the rest of it is zero.
00182 *
00183       ELSE IF( IMAT.LE.9 ) THEN
00184          TNORM = SQRT( CNDNUM )
00185 *
00186 *        Initialize AB to zero.
00187 *
00188          IF( UPPER ) THEN
00189             DO 60 J = 1, N
00190                DO 50 I = MAX( 1, KD+2-J ), KD
00191                   AB( I, J ) = ZERO
00192    50          CONTINUE
00193                AB( KD+1, J ) = DBLE( J )
00194    60       CONTINUE
00195          ELSE
00196             DO 80 J = 1, N
00197                DO 70 I = 2, MIN( KD+1, N-J+1 )
00198                   AB( I, J ) = ZERO
00199    70          CONTINUE
00200                AB( 1, J ) = DBLE( J )
00201    80       CONTINUE
00202          END IF
00203 *
00204 *        Special case:  T is tridiagonal.  Set every other offdiagonal
00205 *        so that the matrix has norm TNORM+1.
00206 *
00207          IF( KD.EQ.1 ) THEN
00208             IF( UPPER ) THEN
00209                AB( 1, 2 ) = TNORM*ZLARND( 5, ISEED )
00210                LENJ = ( N-3 ) / 2
00211                CALL ZLARNV( 2, ISEED, LENJ, WORK )
00212                DO 90 J = 1, LENJ
00213                   AB( 1, 2*( J+1 ) ) = TNORM*WORK( J )
00214    90          CONTINUE
00215             ELSE
00216                AB( 2, 1 ) = TNORM*ZLARND( 5, ISEED )
00217                LENJ = ( N-3 ) / 2
00218                CALL ZLARNV( 2, ISEED, LENJ, WORK )
00219                DO 100 J = 1, LENJ
00220                   AB( 2, 2*J+1 ) = TNORM*WORK( J )
00221   100          CONTINUE
00222             END IF
00223          ELSE IF( KD.GT.1 ) THEN
00224 *
00225 *           Form a unit triangular matrix T with condition CNDNUM.  T is
00226 *           given by
00227 *                   | 1   +   *                      |
00228 *                   |     1   +                      |
00229 *               T = |         1   +   *              |
00230 *                   |             1   +              |
00231 *                   |                 1   +   *      |
00232 *                   |                     1   +      |
00233 *                   |                          . . . |
00234 *        Each element marked with a '*' is formed by taking the product
00235 *        of the adjacent elements marked with '+'.  The '*'s can be
00236 *        chosen freely, and the '+'s are chosen so that the inverse of
00237 *        T will have elements of the same magnitude as T.
00238 *
00239 *        The two offdiagonals of T are stored in WORK.
00240 *
00241             STAR1 = TNORM*ZLARND( 5, ISEED )
00242             SFAC = SQRT( TNORM )
00243             PLUS1 = SFAC*ZLARND( 5, ISEED )
00244             DO 110 J = 1, N, 2
00245                PLUS2 = STAR1 / PLUS1
00246                WORK( J ) = PLUS1
00247                WORK( N+J ) = STAR1
00248                IF( J+1.LE.N ) THEN
00249                   WORK( J+1 ) = PLUS2
00250                   WORK( N+J+1 ) = ZERO
00251                   PLUS1 = STAR1 / PLUS2
00252 *
00253 *                 Generate a new *-value with norm between sqrt(TNORM)
00254 *                 and TNORM.
00255 *
00256                   REXP = DLARND( 2, ISEED )
00257                   IF( REXP.LT.ZERO ) THEN
00258                      STAR1 = -SFAC**( ONE-REXP )*ZLARND( 5, ISEED )
00259                   ELSE
00260                      STAR1 = SFAC**( ONE+REXP )*ZLARND( 5, ISEED )
00261                   END IF
00262                END IF
00263   110       CONTINUE
00264 *
00265 *           Copy the tridiagonal T to AB.
00266 *
00267             IF( UPPER ) THEN
00268                CALL ZCOPY( N-1, WORK, 1, AB( KD, 2 ), LDAB )
00269                CALL ZCOPY( N-2, WORK( N+1 ), 1, AB( KD-1, 3 ), LDAB )
00270             ELSE
00271                CALL ZCOPY( N-1, WORK, 1, AB( 2, 1 ), LDAB )
00272                CALL ZCOPY( N-2, WORK( N+1 ), 1, AB( 3, 1 ), LDAB )
00273             END IF
00274          END IF
00275 *
00276 *     IMAT > 9:  Pathological test cases.  These triangular matrices
00277 *     are badly scaled or badly conditioned, so when used in solving a
00278 *     triangular system they may cause overflow in the solution vector.
00279 *
00280       ELSE IF( IMAT.EQ.10 ) THEN
00281 *
00282 *        Type 10:  Generate a triangular matrix with elements between
00283 *        -1 and 1. Give the diagonal norm 2 to make it well-conditioned.
00284 *        Make the right hand side large so that it requires scaling.
00285 *
00286          IF( UPPER ) THEN
00287             DO 120 J = 1, N
00288                LENJ = MIN( J-1, KD )
00289                CALL ZLARNV( 4, ISEED, LENJ, AB( KD+1-LENJ, J ) )
00290                AB( KD+1, J ) = ZLARND( 5, ISEED )*TWO
00291   120       CONTINUE
00292          ELSE
00293             DO 130 J = 1, N
00294                LENJ = MIN( N-J, KD )
00295                IF( LENJ.GT.0 )
00296      \$            CALL ZLARNV( 4, ISEED, LENJ, AB( 2, J ) )
00297                AB( 1, J ) = ZLARND( 5, ISEED )*TWO
00298   130       CONTINUE
00299          END IF
00300 *
00301 *        Set the right hand side so that the largest value is BIGNUM.
00302 *
00303          CALL ZLARNV( 2, ISEED, N, B )
00304          IY = IZAMAX( N, B, 1 )
00305          BNORM = ABS( B( IY ) )
00306          BSCAL = BIGNUM / MAX( ONE, BNORM )
00307          CALL ZDSCAL( N, BSCAL, B, 1 )
00308 *
00309       ELSE IF( IMAT.EQ.11 ) THEN
00310 *
00311 *        Type 11:  Make the first diagonal element in the solve small to
00312 *        cause immediate overflow when dividing by T(j,j).
00313 *        In type 11, the offdiagonal elements are small (CNORM(j) < 1).
00314 *
00315          CALL ZLARNV( 2, ISEED, N, B )
00316          TSCAL = ONE / DBLE( KD+1 )
00317          IF( UPPER ) THEN
00318             DO 140 J = 1, N
00319                LENJ = MIN( J-1, KD )
00320                IF( LENJ.GT.0 ) THEN
00321                   CALL ZLARNV( 4, ISEED, LENJ, AB( KD+2-LENJ, J ) )
00322                   CALL ZDSCAL( LENJ, TSCAL, AB( KD+2-LENJ, J ), 1 )
00323                END IF
00324                AB( KD+1, J ) = ZLARND( 5, ISEED )
00325   140       CONTINUE
00326             AB( KD+1, N ) = SMLNUM*AB( KD+1, N )
00327          ELSE
00328             DO 150 J = 1, N
00329                LENJ = MIN( N-J, KD )
00330                IF( LENJ.GT.0 ) THEN
00331                   CALL ZLARNV( 4, ISEED, LENJ, AB( 2, J ) )
00332                   CALL ZDSCAL( LENJ, TSCAL, AB( 2, J ), 1 )
00333                END IF
00334                AB( 1, J ) = ZLARND( 5, ISEED )
00335   150       CONTINUE
00336             AB( 1, 1 ) = SMLNUM*AB( 1, 1 )
00337          END IF
00338 *
00339       ELSE IF( IMAT.EQ.12 ) THEN
00340 *
00341 *        Type 12:  Make the first diagonal element in the solve small to
00342 *        cause immediate overflow when dividing by T(j,j).
00343 *        In type 12, the offdiagonal elements are O(1) (CNORM(j) > 1).
00344 *
00345          CALL ZLARNV( 2, ISEED, N, B )
00346          IF( UPPER ) THEN
00347             DO 160 J = 1, N
00348                LENJ = MIN( J-1, KD )
00349                IF( LENJ.GT.0 )
00350      \$            CALL ZLARNV( 4, ISEED, LENJ, AB( KD+2-LENJ, J ) )
00351                AB( KD+1, J ) = ZLARND( 5, ISEED )
00352   160       CONTINUE
00353             AB( KD+1, N ) = SMLNUM*AB( KD+1, N )
00354          ELSE
00355             DO 170 J = 1, N
00356                LENJ = MIN( N-J, KD )
00357                IF( LENJ.GT.0 )
00358      \$            CALL ZLARNV( 4, ISEED, LENJ, AB( 2, J ) )
00359                AB( 1, J ) = ZLARND( 5, ISEED )
00360   170       CONTINUE
00361             AB( 1, 1 ) = SMLNUM*AB( 1, 1 )
00362          END IF
00363 *
00364       ELSE IF( IMAT.EQ.13 ) THEN
00365 *
00366 *        Type 13:  T is diagonal with small numbers on the diagonal to
00367 *        make the growth factor underflow, but a small right hand side
00368 *        chosen so that the solution does not overflow.
00369 *
00370          IF( UPPER ) THEN
00371             JCOUNT = 1
00372             DO 190 J = N, 1, -1
00373                DO 180 I = MAX( 1, KD+1-( J-1 ) ), KD
00374                   AB( I, J ) = ZERO
00375   180          CONTINUE
00376                IF( JCOUNT.LE.2 ) THEN
00377                   AB( KD+1, J ) = SMLNUM*ZLARND( 5, ISEED )
00378                ELSE
00379                   AB( KD+1, J ) = ZLARND( 5, ISEED )
00380                END IF
00381                JCOUNT = JCOUNT + 1
00382                IF( JCOUNT.GT.4 )
00383      \$            JCOUNT = 1
00384   190       CONTINUE
00385          ELSE
00386             JCOUNT = 1
00387             DO 210 J = 1, N
00388                DO 200 I = 2, MIN( N-J+1, KD+1 )
00389                   AB( I, J ) = ZERO
00390   200          CONTINUE
00391                IF( JCOUNT.LE.2 ) THEN
00392                   AB( 1, J ) = SMLNUM*ZLARND( 5, ISEED )
00393                ELSE
00394                   AB( 1, J ) = ZLARND( 5, ISEED )
00395                END IF
00396                JCOUNT = JCOUNT + 1
00397                IF( JCOUNT.GT.4 )
00398      \$            JCOUNT = 1
00399   210       CONTINUE
00400          END IF
00401 *
00402 *        Set the right hand side alternately zero and small.
00403 *
00404          IF( UPPER ) THEN
00405             B( 1 ) = ZERO
00406             DO 220 I = N, 2, -2
00407                B( I ) = ZERO
00408                B( I-1 ) = SMLNUM*ZLARND( 5, ISEED )
00409   220       CONTINUE
00410          ELSE
00411             B( N ) = ZERO
00412             DO 230 I = 1, N - 1, 2
00413                B( I ) = ZERO
00414                B( I+1 ) = SMLNUM*ZLARND( 5, ISEED )
00415   230       CONTINUE
00416          END IF
00417 *
00418       ELSE IF( IMAT.EQ.14 ) THEN
00419 *
00420 *        Type 14:  Make the diagonal elements small to cause gradual
00421 *        overflow when dividing by T(j,j).  To control the amount of
00422 *        scaling needed, the matrix is bidiagonal.
00423 *
00424          TEXP = ONE / DBLE( KD+1 )
00425          TSCAL = SMLNUM**TEXP
00426          CALL ZLARNV( 4, ISEED, N, B )
00427          IF( UPPER ) THEN
00428             DO 250 J = 1, N
00429                DO 240 I = MAX( 1, KD+2-J ), KD
00430                   AB( I, J ) = ZERO
00431   240          CONTINUE
00432                IF( J.GT.1 .AND. KD.GT.0 )
00433      \$            AB( KD, J ) = DCMPLX( -ONE, -ONE )
00434                AB( KD+1, J ) = TSCAL*ZLARND( 5, ISEED )
00435   250       CONTINUE
00436             B( N ) = DCMPLX( ONE, ONE )
00437          ELSE
00438             DO 270 J = 1, N
00439                DO 260 I = 3, MIN( N-J+1, KD+1 )
00440                   AB( I, J ) = ZERO
00441   260          CONTINUE
00442                IF( J.LT.N .AND. KD.GT.0 )
00443      \$            AB( 2, J ) = DCMPLX( -ONE, -ONE )
00444                AB( 1, J ) = TSCAL*ZLARND( 5, ISEED )
00445   270       CONTINUE
00446             B( 1 ) = DCMPLX( ONE, ONE )
00447          END IF
00448 *
00449       ELSE IF( IMAT.EQ.15 ) THEN
00450 *
00451 *        Type 15:  One zero diagonal element.
00452 *
00453          IY = N / 2 + 1
00454          IF( UPPER ) THEN
00455             DO 280 J = 1, N
00456                LENJ = MIN( J, KD+1 )
00457                CALL ZLARNV( 4, ISEED, LENJ, AB( KD+2-LENJ, J ) )
00458                IF( J.NE.IY ) THEN
00459                   AB( KD+1, J ) = ZLARND( 5, ISEED )*TWO
00460                ELSE
00461                   AB( KD+1, J ) = ZERO
00462                END IF
00463   280       CONTINUE
00464          ELSE
00465             DO 290 J = 1, N
00466                LENJ = MIN( N-J+1, KD+1 )
00467                CALL ZLARNV( 4, ISEED, LENJ, AB( 1, J ) )
00468                IF( J.NE.IY ) THEN
00469                   AB( 1, J ) = ZLARND( 5, ISEED )*TWO
00470                ELSE
00471                   AB( 1, J ) = ZERO
00472                END IF
00473   290       CONTINUE
00474          END IF
00475          CALL ZLARNV( 2, ISEED, N, B )
00476          CALL ZDSCAL( N, TWO, B, 1 )
00477 *
00478       ELSE IF( IMAT.EQ.16 ) THEN
00479 *
00480 *        Type 16:  Make the offdiagonal elements large to cause overflow
00481 *        when adding a column of T.  In the non-transposed case, the
00482 *        matrix is constructed to cause overflow when adding a column in
00483 *        every other step.
00484 *
00485          TSCAL = UNFL / ULP
00486          TSCAL = ( ONE-ULP ) / TSCAL
00487          DO 310 J = 1, N
00488             DO 300 I = 1, KD + 1
00489                AB( I, J ) = ZERO
00490   300       CONTINUE
00491   310    CONTINUE
00492          TEXP = ONE
00493          IF( KD.GT.0 ) THEN
00494             IF( UPPER ) THEN
00495                DO 330 J = N, 1, -KD
00496                   DO 320 I = J, MAX( 1, J-KD+1 ), -2
00497                      AB( 1+( J-I ), I ) = -TSCAL / DBLE( KD+2 )
00498                      AB( KD+1, I ) = ONE
00499                      B( I ) = TEXP*( ONE-ULP )
00500                      IF( I.GT.MAX( 1, J-KD+1 ) ) THEN
00501                         AB( 2+( J-I ), I-1 ) = -( TSCAL / DBLE( KD+2 ) )
00502      \$                                          / DBLE( KD+3 )
00503                         AB( KD+1, I-1 ) = ONE
00504                         B( I-1 ) = TEXP*DBLE( ( KD+1 )*( KD+1 )+KD )
00505                      END IF
00506                      TEXP = TEXP*TWO
00507   320             CONTINUE
00508                   B( MAX( 1, J-KD+1 ) ) = ( DBLE( KD+2 ) /
00509      \$                                    DBLE( KD+3 ) )*TSCAL
00510   330          CONTINUE
00511             ELSE
00512                DO 350 J = 1, N, KD
00513                   TEXP = ONE
00514                   LENJ = MIN( KD+1, N-J+1 )
00515                   DO 340 I = J, MIN( N, J+KD-1 ), 2
00516                      AB( LENJ-( I-J ), J ) = -TSCAL / DBLE( KD+2 )
00517                      AB( 1, J ) = ONE
00518                      B( J ) = TEXP*( ONE-ULP )
00519                      IF( I.LT.MIN( N, J+KD-1 ) ) THEN
00520                         AB( LENJ-( I-J+1 ), I+1 ) = -( TSCAL /
00521      \$                     DBLE( KD+2 ) ) / DBLE( KD+3 )
00522                         AB( 1, I+1 ) = ONE
00523                         B( I+1 ) = TEXP*DBLE( ( KD+1 )*( KD+1 )+KD )
00524                      END IF
00525                      TEXP = TEXP*TWO
00526   340             CONTINUE
00527                   B( MIN( N, J+KD-1 ) ) = ( DBLE( KD+2 ) /
00528      \$                                    DBLE( KD+3 ) )*TSCAL
00529   350          CONTINUE
00530             END IF
00531          END IF
00532 *
00533       ELSE IF( IMAT.EQ.17 ) THEN
00534 *
00535 *        Type 17:  Generate a unit triangular matrix with elements
00536 *        between -1 and 1, and make the right hand side large so that it
00537 *        requires scaling.
00538 *
00539          IF( UPPER ) THEN
00540             DO 360 J = 1, N
00541                LENJ = MIN( J-1, KD )
00542                CALL ZLARNV( 4, ISEED, LENJ, AB( KD+1-LENJ, J ) )
00543                AB( KD+1, J ) = DBLE( J )
00544   360       CONTINUE
00545          ELSE
00546             DO 370 J = 1, N
00547                LENJ = MIN( N-J, KD )
00548                IF( LENJ.GT.0 )
00549      \$            CALL ZLARNV( 4, ISEED, LENJ, AB( 2, J ) )
00550                AB( 1, J ) = DBLE( J )
00551   370       CONTINUE
00552          END IF
00553 *
00554 *        Set the right hand side so that the largest value is BIGNUM.
00555 *
00556          CALL ZLARNV( 2, ISEED, N, B )
00557          IY = IZAMAX( N, B, 1 )
00558          BNORM = ABS( B( IY ) )
00559          BSCAL = BIGNUM / MAX( ONE, BNORM )
00560          CALL ZDSCAL( N, BSCAL, B, 1 )
00561 *
00562       ELSE IF( IMAT.EQ.18 ) THEN
00563 *
00564 *        Type 18:  Generate a triangular matrix with elements between
00565 *        BIGNUM/(KD+1) and BIGNUM so that at least one of the column
00566 *        norms will exceed BIGNUM.
00567 *        1/3/91:  ZLATBS no longer can handle this case
00568 *
00569          TLEFT = BIGNUM / DBLE( KD+1 )
00570          TSCAL = BIGNUM*( DBLE( KD+1 ) / DBLE( KD+2 ) )
00571          IF( UPPER ) THEN
00572             DO 390 J = 1, N
00573                LENJ = MIN( J, KD+1 )
00574                CALL ZLARNV( 5, ISEED, LENJ, AB( KD+2-LENJ, J ) )
00575                CALL DLARNV( 1, ISEED, LENJ, RWORK( KD+2-LENJ ) )
00576                DO 380 I = KD + 2 - LENJ, KD + 1
00577                   AB( I, J ) = AB( I, J )*( TLEFT+RWORK( I )*TSCAL )
00578   380          CONTINUE
00579   390       CONTINUE
00580          ELSE
00581             DO 410 J = 1, N
00582                LENJ = MIN( N-J+1, KD+1 )
00583                CALL ZLARNV( 5, ISEED, LENJ, AB( 1, J ) )
00584                CALL DLARNV( 1, ISEED, LENJ, RWORK )
00585                DO 400 I = 1, LENJ
00586                   AB( I, J ) = AB( I, J )*( TLEFT+RWORK( I )*TSCAL )
00587   400          CONTINUE
00588   410       CONTINUE
00589          END IF
00590          CALL ZLARNV( 2, ISEED, N, B )
00591          CALL ZDSCAL( N, TWO, B, 1 )
00592       END IF
00593 *
00594 *     Flip the matrix if the transpose will be used.
00595 *
00596       IF( .NOT.LSAME( TRANS, 'N' ) ) THEN
00597          IF( UPPER ) THEN
00598             DO 420 J = 1, N / 2
00599                LENJ = MIN( N-2*J+1, KD+1 )
00600                CALL ZSWAP( LENJ, AB( KD+1, J ), LDAB-1,
00601      \$                     AB( KD+2-LENJ, N-J+1 ), -1 )
00602   420       CONTINUE
00603          ELSE
00604             DO 430 J = 1, N / 2
00605                LENJ = MIN( N-2*J+1, KD+1 )
00606                CALL ZSWAP( LENJ, AB( 1, J ), 1, AB( LENJ, N-J+2-LENJ ),
00607      \$                     -LDAB+1 )
00608   430       CONTINUE
00609          END IF
00610       END IF
00611 *
00612       RETURN
00613 *
00614 *     End of ZLATTB
00615 *
00616       END
```