|
LAPACK 3.3.0
|
|
LAPACK 3.3.0
|
00001 SUBROUTINE ZLATTP( IMAT, UPLO, TRANS, DIAG, ISEED, N, AP, B, WORK, 00002 $ 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, N 00011 * .. 00012 * .. Array Arguments .. 00013 INTEGER ISEED( 4 ) 00014 DOUBLE PRECISION RWORK( * ) 00015 COMPLEX*16 AP( * ), B( * ), WORK( * ) 00016 * .. 00017 * 00018 * Purpose 00019 * ======= 00020 * 00021 * ZLATTP generates a triangular test matrix in packed storage. 00022 * IMAT and UPLO uniquely specify the properties of the test matrix, 00023 * which is returned in the array AP. 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 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 * AP (output) COMPLEX*16 array, dimension (N*(N+1)/2) 00057 * The upper or lower triangular matrix A, packed columnwise in 00058 * a linear array. The j-th column of A is stored in the array 00059 * AP as follows: 00060 * if UPLO = 'U', AP((j-1)*j/2 + i) = A(i,j) for 1<=i<=j; 00061 * if UPLO = 'L', 00062 * AP((j-1)*(n-j) + j*(j+1)/2 + i-j) = A(i,j) for j<=i<=n. 00063 * 00064 * B (output) COMPLEX*16 array, dimension (N) 00065 * The right hand side vector, if IMAT > 10. 00066 * 00067 * WORK (workspace) COMPLEX*16 array, dimension (2*N) 00068 * 00069 * RWORK (workspace) DOUBLE PRECISION array, dimension (N) 00070 * 00071 * INFO (output) INTEGER 00072 * = 0: successful exit 00073 * < 0: if INFO = -i, the i-th argument had an illegal value 00074 * 00075 * ===================================================================== 00076 * 00077 * .. Parameters .. 00078 DOUBLE PRECISION ONE, TWO, ZERO 00079 PARAMETER ( ONE = 1.0D+0, TWO = 2.0D+0, ZERO = 0.0D+0 ) 00080 * .. 00081 * .. Local Scalars .. 00082 LOGICAL UPPER 00083 CHARACTER DIST, PACKIT, TYPE 00084 CHARACTER*3 PATH 00085 INTEGER I, IY, J, JC, JCNEXT, JCOUNT, JJ, JL, JR, JX, 00086 $ KL, KU, MODE 00087 DOUBLE PRECISION ANORM, BIGNUM, BNORM, BSCAL, C, CNDNUM, REXP, 00088 $ SFAC, SMLNUM, T, TEXP, TLEFT, TSCAL, ULP, UNFL, 00089 $ X, Y, Z 00090 COMPLEX*16 CTEMP, PLUS1, PLUS2, RA, RB, S, STAR1 00091 * .. 00092 * .. External Functions .. 00093 LOGICAL LSAME 00094 INTEGER IZAMAX 00095 DOUBLE PRECISION DLAMCH 00096 COMPLEX*16 ZLARND 00097 EXTERNAL LSAME, IZAMAX, DLAMCH, ZLARND 00098 * .. 00099 * .. External Subroutines .. 00100 EXTERNAL DLABAD, DLARNV, ZDSCAL, ZLARNV, ZLATB4, ZLATMS, 00101 $ ZROT, ZROTG 00102 * .. 00103 * .. Intrinsic Functions .. 00104 INTRINSIC ABS, DBLE, DCMPLX, DCONJG, MAX, SQRT 00105 * .. 00106 * .. Executable Statements .. 00107 * 00108 PATH( 1: 1 ) = 'Zomplex precision' 00109 PATH( 2: 3 ) = 'TP' 00110 UNFL = DLAMCH( 'Safe minimum' ) 00111 ULP = DLAMCH( 'Epsilon' )*DLAMCH( 'Base' ) 00112 SMLNUM = UNFL 00113 BIGNUM = ( ONE-ULP ) / SMLNUM 00114 CALL DLABAD( SMLNUM, BIGNUM ) 00115 IF( ( IMAT.GE.7 .AND. IMAT.LE.10 ) .OR. IMAT.EQ.18 ) THEN 00116 DIAG = 'U' 00117 ELSE 00118 DIAG = 'N' 00119 END IF 00120 INFO = 0 00121 * 00122 * Quick return if N.LE.0. 00123 * 00124 IF( N.LE.0 ) 00125 $ RETURN 00126 * 00127 * Call ZLATB4 to set parameters for CLATMS. 00128 * 00129 UPPER = LSAME( UPLO, 'U' ) 00130 IF( UPPER ) THEN 00131 CALL ZLATB4( PATH, IMAT, N, N, TYPE, KL, KU, ANORM, MODE, 00132 $ CNDNUM, DIST ) 00133 PACKIT = 'C' 00134 ELSE 00135 CALL ZLATB4( PATH, -IMAT, N, N, TYPE, KL, KU, ANORM, MODE, 00136 $ CNDNUM, DIST ) 00137 PACKIT = 'R' 00138 END IF 00139 * 00140 * IMAT <= 6: Non-unit triangular matrix 00141 * 00142 IF( IMAT.LE.6 ) THEN 00143 CALL ZLATMS( N, N, DIST, ISEED, TYPE, RWORK, MODE, CNDNUM, 00144 $ ANORM, KL, KU, PACKIT, AP, N, WORK, INFO ) 00145 * 00146 * IMAT > 6: Unit triangular matrix 00147 * The diagonal is deliberately set to something other than 1. 00148 * 00149 * IMAT = 7: Matrix is the identity 00150 * 00151 ELSE IF( IMAT.EQ.7 ) THEN 00152 IF( UPPER ) THEN 00153 JC = 1 00154 DO 20 J = 1, N 00155 DO 10 I = 1, J - 1 00156 AP( JC+I-1 ) = ZERO 00157 10 CONTINUE 00158 AP( JC+J-1 ) = J 00159 JC = JC + J 00160 20 CONTINUE 00161 ELSE 00162 JC = 1 00163 DO 40 J = 1, N 00164 AP( JC ) = J 00165 DO 30 I = J + 1, N 00166 AP( JC+I-J ) = ZERO 00167 30 CONTINUE 00168 JC = JC + N - J + 1 00169 40 CONTINUE 00170 END IF 00171 * 00172 * IMAT > 7: Non-trivial unit triangular matrix 00173 * 00174 * Generate a unit triangular matrix T with condition CNDNUM by 00175 * forming a triangular matrix with known singular values and 00176 * filling in the zero entries with Givens rotations. 00177 * 00178 ELSE IF( IMAT.LE.10 ) THEN 00179 IF( UPPER ) THEN 00180 JC = 0 00181 DO 60 J = 1, N 00182 DO 50 I = 1, J - 1 00183 AP( JC+I ) = ZERO 00184 50 CONTINUE 00185 AP( JC+J ) = J 00186 JC = JC + J 00187 60 CONTINUE 00188 ELSE 00189 JC = 1 00190 DO 80 J = 1, N 00191 AP( JC ) = J 00192 DO 70 I = J + 1, N 00193 AP( JC+I-J ) = ZERO 00194 70 CONTINUE 00195 JC = JC + N - J + 1 00196 80 CONTINUE 00197 END IF 00198 * 00199 * Since the trace of a unit triangular matrix is 1, the product 00200 * of its singular values must be 1. Let s = sqrt(CNDNUM), 00201 * x = sqrt(s) - 1/sqrt(s), y = sqrt(2/(n-2))*x, and z = x**2. 00202 * The following triangular matrix has singular values s, 1, 1, 00203 * ..., 1, 1/s: 00204 * 00205 * 1 y y y ... y y z 00206 * 1 0 0 ... 0 0 y 00207 * 1 0 ... 0 0 y 00208 * . ... . . . 00209 * . . . . 00210 * 1 0 y 00211 * 1 y 00212 * 1 00213 * 00214 * To fill in the zeros, we first multiply by a matrix with small 00215 * condition number of the form 00216 * 00217 * 1 0 0 0 0 ... 00218 * 1 + * 0 0 ... 00219 * 1 + 0 0 0 00220 * 1 + * 0 0 00221 * 1 + 0 0 00222 * ... 00223 * 1 + 0 00224 * 1 0 00225 * 1 00226 * 00227 * Each element marked with a '*' is formed by taking the product 00228 * of the adjacent elements marked with '+'. The '*'s can be 00229 * chosen freely, and the '+'s are chosen so that the inverse of 00230 * T will have elements of the same magnitude as T. If the *'s in 00231 * both T and inv(T) have small magnitude, T is well conditioned. 00232 * The two offdiagonals of T are stored in WORK. 00233 * 00234 * The product of these two matrices has the form 00235 * 00236 * 1 y y y y y . y y z 00237 * 1 + * 0 0 . 0 0 y 00238 * 1 + 0 0 . 0 0 y 00239 * 1 + * . . . . 00240 * 1 + . . . . 00241 * . . . . . 00242 * . . . . 00243 * 1 + y 00244 * 1 y 00245 * 1 00246 * 00247 * Now we multiply by Givens rotations, using the fact that 00248 * 00249 * [ c s ] [ 1 w ] [ -c -s ] = [ 1 -w ] 00250 * [ -s c ] [ 0 1 ] [ s -c ] [ 0 1 ] 00251 * and 00252 * [ -c -s ] [ 1 0 ] [ c s ] = [ 1 0 ] 00253 * [ s -c ] [ w 1 ] [ -s c ] [ -w 1 ] 00254 * 00255 * where c = w / sqrt(w**2+4) and s = 2 / sqrt(w**2+4). 00256 * 00257 STAR1 = 0.25D0*ZLARND( 5, ISEED ) 00258 SFAC = 0.5D0 00259 PLUS1 = SFAC*ZLARND( 5, ISEED ) 00260 DO 90 J = 1, N, 2 00261 PLUS2 = STAR1 / PLUS1 00262 WORK( J ) = PLUS1 00263 WORK( N+J ) = STAR1 00264 IF( J+1.LE.N ) THEN 00265 WORK( J+1 ) = PLUS2 00266 WORK( N+J+1 ) = ZERO 00267 PLUS1 = STAR1 / PLUS2 00268 REXP = ZLARND( 2, ISEED ) 00269 IF( REXP.LT.ZERO ) THEN 00270 STAR1 = -SFAC**( ONE-REXP )*ZLARND( 5, ISEED ) 00271 ELSE 00272 STAR1 = SFAC**( ONE+REXP )*ZLARND( 5, ISEED ) 00273 END IF 00274 END IF 00275 90 CONTINUE 00276 * 00277 X = SQRT( CNDNUM ) - ONE / SQRT( CNDNUM ) 00278 IF( N.GT.2 ) THEN 00279 Y = SQRT( TWO / DBLE( N-2 ) )*X 00280 ELSE 00281 Y = ZERO 00282 END IF 00283 Z = X*X 00284 * 00285 IF( UPPER ) THEN 00286 * 00287 * Set the upper triangle of A with a unit triangular matrix 00288 * of known condition number. 00289 * 00290 JC = 1 00291 DO 100 J = 2, N 00292 AP( JC+1 ) = Y 00293 IF( J.GT.2 ) 00294 $ AP( JC+J-1 ) = WORK( J-2 ) 00295 IF( J.GT.3 ) 00296 $ AP( JC+J-2 ) = WORK( N+J-3 ) 00297 JC = JC + J 00298 100 CONTINUE 00299 JC = JC - N 00300 AP( JC+1 ) = Z 00301 DO 110 J = 2, N - 1 00302 AP( JC+J ) = Y 00303 110 CONTINUE 00304 ELSE 00305 * 00306 * Set the lower triangle of A with a unit triangular matrix 00307 * of known condition number. 00308 * 00309 DO 120 I = 2, N - 1 00310 AP( I ) = Y 00311 120 CONTINUE 00312 AP( N ) = Z 00313 JC = N + 1 00314 DO 130 J = 2, N - 1 00315 AP( JC+1 ) = WORK( J-1 ) 00316 IF( J.LT.N-1 ) 00317 $ AP( JC+2 ) = WORK( N+J-1 ) 00318 AP( JC+N-J ) = Y 00319 JC = JC + N - J + 1 00320 130 CONTINUE 00321 END IF 00322 * 00323 * Fill in the zeros using Givens rotations 00324 * 00325 IF( UPPER ) THEN 00326 JC = 1 00327 DO 150 J = 1, N - 1 00328 JCNEXT = JC + J 00329 RA = AP( JCNEXT+J-1 ) 00330 RB = TWO 00331 CALL ZROTG( RA, RB, C, S ) 00332 * 00333 * Multiply by [ c s; -conjg(s) c] on the left. 00334 * 00335 IF( N.GT.J+1 ) THEN 00336 JX = JCNEXT + J 00337 DO 140 I = J + 2, N 00338 CTEMP = C*AP( JX+J ) + S*AP( JX+J+1 ) 00339 AP( JX+J+1 ) = -DCONJG( S )*AP( JX+J ) + 00340 $ C*AP( JX+J+1 ) 00341 AP( JX+J ) = CTEMP 00342 JX = JX + I 00343 140 CONTINUE 00344 END IF 00345 * 00346 * Multiply by [-c -s; conjg(s) -c] on the right. 00347 * 00348 IF( J.GT.1 ) 00349 $ CALL ZROT( J-1, AP( JCNEXT ), 1, AP( JC ), 1, -C, -S ) 00350 * 00351 * Negate A(J,J+1). 00352 * 00353 AP( JCNEXT+J-1 ) = -AP( JCNEXT+J-1 ) 00354 JC = JCNEXT 00355 150 CONTINUE 00356 ELSE 00357 JC = 1 00358 DO 170 J = 1, N - 1 00359 JCNEXT = JC + N - J + 1 00360 RA = AP( JC+1 ) 00361 RB = TWO 00362 CALL ZROTG( RA, RB, C, S ) 00363 S = DCONJG( S ) 00364 * 00365 * Multiply by [ c -s; conjg(s) c] on the right. 00366 * 00367 IF( N.GT.J+1 ) 00368 $ CALL ZROT( N-J-1, AP( JCNEXT+1 ), 1, AP( JC+2 ), 1, C, 00369 $ -S ) 00370 * 00371 * Multiply by [-c s; -conjg(s) -c] on the left. 00372 * 00373 IF( J.GT.1 ) THEN 00374 JX = 1 00375 DO 160 I = 1, J - 1 00376 CTEMP = -C*AP( JX+J-I ) + S*AP( JX+J-I+1 ) 00377 AP( JX+J-I+1 ) = -DCONJG( S )*AP( JX+J-I ) - 00378 $ C*AP( JX+J-I+1 ) 00379 AP( JX+J-I ) = CTEMP 00380 JX = JX + N - I + 1 00381 160 CONTINUE 00382 END IF 00383 * 00384 * Negate A(J+1,J). 00385 * 00386 AP( JC+1 ) = -AP( JC+1 ) 00387 JC = JCNEXT 00388 170 CONTINUE 00389 END IF 00390 * 00391 * IMAT > 10: Pathological test cases. These triangular matrices 00392 * are badly scaled or badly conditioned, so when used in solving a 00393 * triangular system they may cause overflow in the solution vector. 00394 * 00395 ELSE IF( IMAT.EQ.11 ) THEN 00396 * 00397 * Type 11: Generate a triangular matrix with elements between 00398 * -1 and 1. Give the diagonal norm 2 to make it well-conditioned. 00399 * Make the right hand side large so that it requires scaling. 00400 * 00401 IF( UPPER ) THEN 00402 JC = 1 00403 DO 180 J = 1, N 00404 CALL ZLARNV( 4, ISEED, J-1, AP( JC ) ) 00405 AP( JC+J-1 ) = ZLARND( 5, ISEED )*TWO 00406 JC = JC + J 00407 180 CONTINUE 00408 ELSE 00409 JC = 1 00410 DO 190 J = 1, N 00411 IF( J.LT.N ) 00412 $ CALL ZLARNV( 4, ISEED, N-J, AP( JC+1 ) ) 00413 AP( JC ) = ZLARND( 5, ISEED )*TWO 00414 JC = JC + N - J + 1 00415 190 CONTINUE 00416 END IF 00417 * 00418 * Set the right hand side so that the largest value is BIGNUM. 00419 * 00420 CALL ZLARNV( 2, ISEED, N, B ) 00421 IY = IZAMAX( N, B, 1 ) 00422 BNORM = ABS( B( IY ) ) 00423 BSCAL = BIGNUM / MAX( ONE, BNORM ) 00424 CALL ZDSCAL( N, BSCAL, B, 1 ) 00425 * 00426 ELSE IF( IMAT.EQ.12 ) THEN 00427 * 00428 * Type 12: Make the first diagonal element in the solve small to 00429 * cause immediate overflow when dividing by T(j,j). 00430 * In type 12, the offdiagonal elements are small (CNORM(j) < 1). 00431 * 00432 CALL ZLARNV( 2, ISEED, N, B ) 00433 TSCAL = ONE / MAX( ONE, DBLE( N-1 ) ) 00434 IF( UPPER ) THEN 00435 JC = 1 00436 DO 200 J = 1, N 00437 CALL ZLARNV( 4, ISEED, J-1, AP( JC ) ) 00438 CALL ZDSCAL( J-1, TSCAL, AP( JC ), 1 ) 00439 AP( JC+J-1 ) = ZLARND( 5, ISEED ) 00440 JC = JC + J 00441 200 CONTINUE 00442 AP( N*( N+1 ) / 2 ) = SMLNUM*AP( N*( N+1 ) / 2 ) 00443 ELSE 00444 JC = 1 00445 DO 210 J = 1, N 00446 CALL ZLARNV( 2, ISEED, N-J, AP( JC+1 ) ) 00447 CALL ZDSCAL( N-J, TSCAL, AP( JC+1 ), 1 ) 00448 AP( JC ) = ZLARND( 5, ISEED ) 00449 JC = JC + N - J + 1 00450 210 CONTINUE 00451 AP( 1 ) = SMLNUM*AP( 1 ) 00452 END IF 00453 * 00454 ELSE IF( IMAT.EQ.13 ) THEN 00455 * 00456 * Type 13: Make the first diagonal element in the solve small to 00457 * cause immediate overflow when dividing by T(j,j). 00458 * In type 13, the offdiagonal elements are O(1) (CNORM(j) > 1). 00459 * 00460 CALL ZLARNV( 2, ISEED, N, B ) 00461 IF( UPPER ) THEN 00462 JC = 1 00463 DO 220 J = 1, N 00464 CALL ZLARNV( 4, ISEED, J-1, AP( JC ) ) 00465 AP( JC+J-1 ) = ZLARND( 5, ISEED ) 00466 JC = JC + J 00467 220 CONTINUE 00468 AP( N*( N+1 ) / 2 ) = SMLNUM*AP( N*( N+1 ) / 2 ) 00469 ELSE 00470 JC = 1 00471 DO 230 J = 1, N 00472 CALL ZLARNV( 4, ISEED, N-J, AP( JC+1 ) ) 00473 AP( JC ) = ZLARND( 5, ISEED ) 00474 JC = JC + N - J + 1 00475 230 CONTINUE 00476 AP( 1 ) = SMLNUM*AP( 1 ) 00477 END IF 00478 * 00479 ELSE IF( IMAT.EQ.14 ) THEN 00480 * 00481 * Type 14: T is diagonal with small numbers on the diagonal to 00482 * make the growth factor underflow, but a small right hand side 00483 * chosen so that the solution does not overflow. 00484 * 00485 IF( UPPER ) THEN 00486 JCOUNT = 1 00487 JC = ( N-1 )*N / 2 + 1 00488 DO 250 J = N, 1, -1 00489 DO 240 I = 1, J - 1 00490 AP( JC+I-1 ) = ZERO 00491 240 CONTINUE 00492 IF( JCOUNT.LE.2 ) THEN 00493 AP( JC+J-1 ) = SMLNUM*ZLARND( 5, ISEED ) 00494 ELSE 00495 AP( JC+J-1 ) = ZLARND( 5, ISEED ) 00496 END IF 00497 JCOUNT = JCOUNT + 1 00498 IF( JCOUNT.GT.4 ) 00499 $ JCOUNT = 1 00500 JC = JC - J + 1 00501 250 CONTINUE 00502 ELSE 00503 JCOUNT = 1 00504 JC = 1 00505 DO 270 J = 1, N 00506 DO 260 I = J + 1, N 00507 AP( JC+I-J ) = ZERO 00508 260 CONTINUE 00509 IF( JCOUNT.LE.2 ) THEN 00510 AP( JC ) = SMLNUM*ZLARND( 5, ISEED ) 00511 ELSE 00512 AP( JC ) = ZLARND( 5, ISEED ) 00513 END IF 00514 JCOUNT = JCOUNT + 1 00515 IF( JCOUNT.GT.4 ) 00516 $ JCOUNT = 1 00517 JC = JC + N - J + 1 00518 270 CONTINUE 00519 END IF 00520 * 00521 * Set the right hand side alternately zero and small. 00522 * 00523 IF( UPPER ) THEN 00524 B( 1 ) = ZERO 00525 DO 280 I = N, 2, -2 00526 B( I ) = ZERO 00527 B( I-1 ) = SMLNUM*ZLARND( 5, ISEED ) 00528 280 CONTINUE 00529 ELSE 00530 B( N ) = ZERO 00531 DO 290 I = 1, N - 1, 2 00532 B( I ) = ZERO 00533 B( I+1 ) = SMLNUM*ZLARND( 5, ISEED ) 00534 290 CONTINUE 00535 END IF 00536 * 00537 ELSE IF( IMAT.EQ.15 ) THEN 00538 * 00539 * Type 15: Make the diagonal elements small to cause gradual 00540 * overflow when dividing by T(j,j). To control the amount of 00541 * scaling needed, the matrix is bidiagonal. 00542 * 00543 TEXP = ONE / MAX( ONE, DBLE( N-1 ) ) 00544 TSCAL = SMLNUM**TEXP 00545 CALL ZLARNV( 4, ISEED, N, B ) 00546 IF( UPPER ) THEN 00547 JC = 1 00548 DO 310 J = 1, N 00549 DO 300 I = 1, J - 2 00550 AP( JC+I-1 ) = ZERO 00551 300 CONTINUE 00552 IF( J.GT.1 ) 00553 $ AP( JC+J-2 ) = DCMPLX( -ONE, -ONE ) 00554 AP( JC+J-1 ) = TSCAL*ZLARND( 5, ISEED ) 00555 JC = JC + J 00556 310 CONTINUE 00557 B( N ) = DCMPLX( ONE, ONE ) 00558 ELSE 00559 JC = 1 00560 DO 330 J = 1, N 00561 DO 320 I = J + 2, N 00562 AP( JC+I-J ) = ZERO 00563 320 CONTINUE 00564 IF( J.LT.N ) 00565 $ AP( JC+1 ) = DCMPLX( -ONE, -ONE ) 00566 AP( JC ) = TSCAL*ZLARND( 5, ISEED ) 00567 JC = JC + N - J + 1 00568 330 CONTINUE 00569 B( 1 ) = DCMPLX( ONE, ONE ) 00570 END IF 00571 * 00572 ELSE IF( IMAT.EQ.16 ) THEN 00573 * 00574 * Type 16: One zero diagonal element. 00575 * 00576 IY = N / 2 + 1 00577 IF( UPPER ) THEN 00578 JC = 1 00579 DO 340 J = 1, N 00580 CALL ZLARNV( 4, ISEED, J, AP( JC ) ) 00581 IF( J.NE.IY ) THEN 00582 AP( JC+J-1 ) = ZLARND( 5, ISEED )*TWO 00583 ELSE 00584 AP( JC+J-1 ) = ZERO 00585 END IF 00586 JC = JC + J 00587 340 CONTINUE 00588 ELSE 00589 JC = 1 00590 DO 350 J = 1, N 00591 CALL ZLARNV( 4, ISEED, N-J+1, AP( JC ) ) 00592 IF( J.NE.IY ) THEN 00593 AP( JC ) = ZLARND( 5, ISEED )*TWO 00594 ELSE 00595 AP( JC ) = ZERO 00596 END IF 00597 JC = JC + N - J + 1 00598 350 CONTINUE 00599 END IF 00600 CALL ZLARNV( 2, ISEED, N, B ) 00601 CALL ZDSCAL( N, TWO, B, 1 ) 00602 * 00603 ELSE IF( IMAT.EQ.17 ) THEN 00604 * 00605 * Type 17: Make the offdiagonal elements large to cause overflow 00606 * when adding a column of T. In the non-transposed case, the 00607 * matrix is constructed to cause overflow when adding a column in 00608 * every other step. 00609 * 00610 TSCAL = UNFL / ULP 00611 TSCAL = ( ONE-ULP ) / TSCAL 00612 DO 360 J = 1, N*( N+1 ) / 2 00613 AP( J ) = ZERO 00614 360 CONTINUE 00615 TEXP = ONE 00616 IF( UPPER ) THEN 00617 JC = ( N-1 )*N / 2 + 1 00618 DO 370 J = N, 2, -2 00619 AP( JC ) = -TSCAL / DBLE( N+1 ) 00620 AP( JC+J-1 ) = ONE 00621 B( J ) = TEXP*( ONE-ULP ) 00622 JC = JC - J + 1 00623 AP( JC ) = -( TSCAL / DBLE( N+1 ) ) / DBLE( N+2 ) 00624 AP( JC+J-2 ) = ONE 00625 B( J-1 ) = TEXP*DBLE( N*N+N-1 ) 00626 TEXP = TEXP*TWO 00627 JC = JC - J + 2 00628 370 CONTINUE 00629 B( 1 ) = ( DBLE( N+1 ) / DBLE( N+2 ) )*TSCAL 00630 ELSE 00631 JC = 1 00632 DO 380 J = 1, N - 1, 2 00633 AP( JC+N-J ) = -TSCAL / DBLE( N+1 ) 00634 AP( JC ) = ONE 00635 B( J ) = TEXP*( ONE-ULP ) 00636 JC = JC + N - J + 1 00637 AP( JC+N-J-1 ) = -( TSCAL / DBLE( N+1 ) ) / DBLE( N+2 ) 00638 AP( JC ) = ONE 00639 B( J+1 ) = TEXP*DBLE( N*N+N-1 ) 00640 TEXP = TEXP*TWO 00641 JC = JC + N - J 00642 380 CONTINUE 00643 B( N ) = ( DBLE( N+1 ) / DBLE( N+2 ) )*TSCAL 00644 END IF 00645 * 00646 ELSE IF( IMAT.EQ.18 ) THEN 00647 * 00648 * Type 18: Generate a unit triangular matrix with elements 00649 * between -1 and 1, and make the right hand side large so that it 00650 * requires scaling. 00651 * 00652 IF( UPPER ) THEN 00653 JC = 1 00654 DO 390 J = 1, N 00655 CALL ZLARNV( 4, ISEED, J-1, AP( JC ) ) 00656 AP( JC+J-1 ) = ZERO 00657 JC = JC + J 00658 390 CONTINUE 00659 ELSE 00660 JC = 1 00661 DO 400 J = 1, N 00662 IF( J.LT.N ) 00663 $ CALL ZLARNV( 4, ISEED, N-J, AP( JC+1 ) ) 00664 AP( JC ) = ZERO 00665 JC = JC + N - J + 1 00666 400 CONTINUE 00667 END IF 00668 * 00669 * Set the right hand side so that the largest value is BIGNUM. 00670 * 00671 CALL ZLARNV( 2, ISEED, N, B ) 00672 IY = IZAMAX( N, B, 1 ) 00673 BNORM = ABS( B( IY ) ) 00674 BSCAL = BIGNUM / MAX( ONE, BNORM ) 00675 CALL ZDSCAL( N, BSCAL, B, 1 ) 00676 * 00677 ELSE IF( IMAT.EQ.19 ) THEN 00678 * 00679 * Type 19: Generate a triangular matrix with elements between 00680 * BIGNUM/(n-1) and BIGNUM so that at least one of the column 00681 * norms will exceed BIGNUM. 00682 * 1/3/91: ZLATPS no longer can handle this case 00683 * 00684 TLEFT = BIGNUM / MAX( ONE, DBLE( N-1 ) ) 00685 TSCAL = BIGNUM*( DBLE( N-1 ) / MAX( ONE, DBLE( N ) ) ) 00686 IF( UPPER ) THEN 00687 JC = 1 00688 DO 420 J = 1, N 00689 CALL ZLARNV( 5, ISEED, J, AP( JC ) ) 00690 CALL DLARNV( 1, ISEED, J, RWORK ) 00691 DO 410 I = 1, J 00692 AP( JC+I-1 ) = AP( JC+I-1 )*( TLEFT+RWORK( I )*TSCAL ) 00693 410 CONTINUE 00694 JC = JC + J 00695 420 CONTINUE 00696 ELSE 00697 JC = 1 00698 DO 440 J = 1, N 00699 CALL ZLARNV( 5, ISEED, N-J+1, AP( JC ) ) 00700 CALL DLARNV( 1, ISEED, N-J+1, RWORK ) 00701 DO 430 I = J, N 00702 AP( JC+I-J ) = AP( JC+I-J )* 00703 $ ( TLEFT+RWORK( I-J+1 )*TSCAL ) 00704 430 CONTINUE 00705 JC = JC + N - J + 1 00706 440 CONTINUE 00707 END IF 00708 CALL ZLARNV( 2, ISEED, N, B ) 00709 CALL ZDSCAL( N, TWO, B, 1 ) 00710 END IF 00711 * 00712 * Flip the matrix across its counter-diagonal if the transpose will 00713 * be used. 00714 * 00715 IF( .NOT.LSAME( TRANS, 'N' ) ) THEN 00716 IF( UPPER ) THEN 00717 JJ = 1 00718 JR = N*( N+1 ) / 2 00719 DO 460 J = 1, N / 2 00720 JL = JJ 00721 DO 450 I = J, N - J 00722 T = AP( JR-I+J ) 00723 AP( JR-I+J ) = AP( JL ) 00724 AP( JL ) = T 00725 JL = JL + I 00726 450 CONTINUE 00727 JJ = JJ + J + 1 00728 JR = JR - ( N-J+1 ) 00729 460 CONTINUE 00730 ELSE 00731 JL = 1 00732 JJ = N*( N+1 ) / 2 00733 DO 480 J = 1, N / 2 00734 JR = JJ 00735 DO 470 I = J, N - J 00736 T = AP( JL+I-J ) 00737 AP( JL+I-J ) = AP( JR ) 00738 AP( JR ) = T 00739 JR = JR - I 00740 470 CONTINUE 00741 JL = JL + N - J + 1 00742 JJ = JJ - J - 1 00743 480 CONTINUE 00744 END IF 00745 END IF 00746 * 00747 RETURN 00748 * 00749 * End of ZLATTP 00750 * 00751 END
1.7.3 
