LAPACK 3.12.0
LAPACK: Linear Algebra PACKage
Loading...
Searching...
No Matches

◆ slattr()

subroutine slattr ( integer  imat,
character  uplo,
character  trans,
character  diag,
integer, dimension( 4 )  iseed,
integer  n,
real, dimension( lda, * )  a,
integer  lda,
real, dimension( * )  b,
real, dimension( * )  work,
integer  info 
)

SLATTR

Purpose:
 SLATTR generates a triangular test matrix.
 IMAT and UPLO uniquely specify the properties of the test
 matrix, which is returned in the array A.
Parameters
[in]IMAT
          IMAT is INTEGER
          An integer key describing which matrix to generate for this
          path.
[in]UPLO
          UPLO is CHARACTER*1
          Specifies whether the matrix A will be upper or lower
          triangular.
          = 'U':  Upper triangular
          = 'L':  Lower triangular
[in]TRANS
          TRANS is CHARACTER*1
          Specifies whether the matrix or its transpose will be used.
          = 'N':  No transpose
          = 'T':  Transpose
          = 'C':  Conjugate transpose (= Transpose)
[out]DIAG
          DIAG is CHARACTER*1
          Specifies whether or not the matrix A is unit triangular.
          = 'N':  Non-unit triangular
          = 'U':  Unit triangular
[in,out]ISEED
          ISEED is INTEGER array, dimension (4)
          The seed vector for the random number generator (used in
          SLATMS).  Modified on exit.
[in]N
          N is INTEGER
          The order of the matrix to be generated.
[out]A
          A is REAL array, dimension (LDA,N)
          The triangular matrix A.  If UPLO = 'U', the leading n by n
          upper triangular part of the array A contains the upper
          triangular matrix, and the strictly lower triangular part of
          A is not referenced.  If UPLO = 'L', the leading n by n lower
          triangular part of the array A contains the lower triangular
          matrix, and the strictly upper triangular part of A is not
          referenced.  If DIAG = 'U', the diagonal elements of A are
          set so that A(k,k) = k for 1 <= k <= n.
[in]LDA
          LDA is INTEGER
          The leading dimension of the array A.  LDA >= max(1,N).
[out]B
          B is REAL array, dimension (N)
          The right hand side vector, if IMAT > 10.
[out]WORK
          WORK is REAL array, dimension (3*N)
[out]INFO
          INFO is INTEGER
          = 0:  successful exit
          < 0: if INFO = -k, the k-th argument had an illegal value
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 131 of file slattr.f.

133*
134* -- LAPACK test routine --
135* -- LAPACK is a software package provided by Univ. of Tennessee, --
136* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
137*
138* .. Scalar Arguments ..
139 CHARACTER DIAG, TRANS, UPLO
140 INTEGER IMAT, INFO, LDA, N
141* ..
142* .. Array Arguments ..
143 INTEGER ISEED( 4 )
144 REAL A( LDA, * ), B( * ), WORK( * )
145* ..
146*
147* =====================================================================
148*
149* .. Parameters ..
150 REAL ONE, TWO, ZERO
151 parameter( one = 1.0e+0, two = 2.0e+0, zero = 0.0e+0 )
152* ..
153* .. Local Scalars ..
154 LOGICAL UPPER
155 CHARACTER DIST, TYPE
156 CHARACTER*3 PATH
157 INTEGER I, IY, J, JCOUNT, KL, KU, MODE
158 REAL ANORM, BIGNUM, BNORM, BSCAL, C, CNDNUM, PLUS1,
159 $ PLUS2, RA, RB, REXP, S, SFAC, SMLNUM, STAR1,
160 $ TEXP, TLEFT, TSCAL, ULP, UNFL, X, Y, Z
161* ..
162* .. External Functions ..
163 LOGICAL LSAME
164 INTEGER ISAMAX
165 REAL SLAMCH, SLARND
166 EXTERNAL lsame, isamax, slamch, slarnd
167* ..
168* .. External Subroutines ..
169 EXTERNAL scopy, slarnv, slatb4, slatms, srot,
170 $ srotg, sscal, sswap
171* ..
172* .. Intrinsic Functions ..
173 INTRINSIC abs, max, real, sign, sqrt
174* ..
175* .. Executable Statements ..
176*
177 path( 1: 1 ) = 'Single precision'
178 path( 2: 3 ) = 'TR'
179 unfl = slamch( 'Safe minimum' )
180 ulp = slamch( 'Epsilon' )*slamch( 'Base' )
181 smlnum = unfl
182 bignum = ( one-ulp ) / smlnum
183 IF( ( imat.GE.7 .AND. imat.LE.10 ) .OR. imat.EQ.18 ) THEN
184 diag = 'U'
185 ELSE
186 diag = 'N'
187 END IF
188 info = 0
189*
190* Quick return if N.LE.0.
191*
192 IF( n.LE.0 )
193 $ RETURN
194*
195* Call SLATB4 to set parameters for SLATMS.
196*
197 upper = lsame( uplo, 'U' )
198 IF( upper ) THEN
199 CALL slatb4( path, imat, n, n, TYPE, KL, KU, ANORM, MODE,
200 $ CNDNUM, DIST )
201 ELSE
202 CALL slatb4( path, -imat, n, n, TYPE, KL, KU, ANORM, MODE,
203 $ CNDNUM, DIST )
204 END IF
205*
206* IMAT <= 6: Non-unit triangular matrix
207*
208 IF( imat.LE.6 ) THEN
209 CALL slatms( n, n, dist, iseed, TYPE, B, MODE, CNDNUM, ANORM,
210 $ KL, KU, 'No packing', A, LDA, WORK, INFO )
211*
212* IMAT > 6: Unit triangular matrix
213* The diagonal is deliberately set to something other than 1.
214*
215* IMAT = 7: Matrix is the identity
216*
217 ELSE IF( imat.EQ.7 ) THEN
218 IF( upper ) THEN
219 DO 20 j = 1, n
220 DO 10 i = 1, j - 1
221 a( i, j ) = zero
222 10 CONTINUE
223 a( j, j ) = j
224 20 CONTINUE
225 ELSE
226 DO 40 j = 1, n
227 a( j, j ) = j
228 DO 30 i = j + 1, n
229 a( i, j ) = zero
230 30 CONTINUE
231 40 CONTINUE
232 END IF
233*
234* IMAT > 7: Non-trivial unit triangular matrix
235*
236* Generate a unit triangular matrix T with condition CNDNUM by
237* forming a triangular matrix with known singular values and
238* filling in the zero entries with Givens rotations.
239*
240 ELSE IF( imat.LE.10 ) THEN
241 IF( upper ) THEN
242 DO 60 j = 1, n
243 DO 50 i = 1, j - 1
244 a( i, j ) = zero
245 50 CONTINUE
246 a( j, j ) = j
247 60 CONTINUE
248 ELSE
249 DO 80 j = 1, n
250 a( j, j ) = j
251 DO 70 i = j + 1, n
252 a( i, j ) = zero
253 70 CONTINUE
254 80 CONTINUE
255 END IF
256*
257* Since the trace of a unit triangular matrix is 1, the product
258* of its singular values must be 1. Let s = sqrt(CNDNUM),
259* x = sqrt(s) - 1/sqrt(s), y = sqrt(2/(n-2))*x, and z = x**2.
260* The following triangular matrix has singular values s, 1, 1,
261* ..., 1, 1/s:
262*
263* 1 y y y ... y y z
264* 1 0 0 ... 0 0 y
265* 1 0 ... 0 0 y
266* . ... . . .
267* . . . .
268* 1 0 y
269* 1 y
270* 1
271*
272* To fill in the zeros, we first multiply by a matrix with small
273* condition number of the form
274*
275* 1 0 0 0 0 ...
276* 1 + * 0 0 ...
277* 1 + 0 0 0
278* 1 + * 0 0
279* 1 + 0 0
280* ...
281* 1 + 0
282* 1 0
283* 1
284*
285* Each element marked with a '*' is formed by taking the product
286* of the adjacent elements marked with '+'. The '*'s can be
287* chosen freely, and the '+'s are chosen so that the inverse of
288* T will have elements of the same magnitude as T. If the *'s in
289* both T and inv(T) have small magnitude, T is well conditioned.
290* The two offdiagonals of T are stored in WORK.
291*
292* The product of these two matrices has the form
293*
294* 1 y y y y y . y y z
295* 1 + * 0 0 . 0 0 y
296* 1 + 0 0 . 0 0 y
297* 1 + * . . . .
298* 1 + . . . .
299* . . . . .
300* . . . .
301* 1 + y
302* 1 y
303* 1
304*
305* Now we multiply by Givens rotations, using the fact that
306*
307* [ c s ] [ 1 w ] [ -c -s ] = [ 1 -w ]
308* [ -s c ] [ 0 1 ] [ s -c ] [ 0 1 ]
309* and
310* [ -c -s ] [ 1 0 ] [ c s ] = [ 1 0 ]
311* [ s -c ] [ w 1 ] [ -s c ] [ -w 1 ]
312*
313* where c = w / sqrt(w**2+4) and s = 2 / sqrt(w**2+4).
314*
315 star1 = 0.25
316 sfac = 0.5
317 plus1 = sfac
318 DO 90 j = 1, n, 2
319 plus2 = star1 / plus1
320 work( j ) = plus1
321 work( n+j ) = star1
322 IF( j+1.LE.n ) THEN
323 work( j+1 ) = plus2
324 work( n+j+1 ) = zero
325 plus1 = star1 / plus2
326 rexp = slarnd( 2, iseed )
327 star1 = star1*( sfac**rexp )
328 IF( rexp.LT.zero ) THEN
329 star1 = -sfac**( one-rexp )
330 ELSE
331 star1 = sfac**( one+rexp )
332 END IF
333 END IF
334 90 CONTINUE
335*
336 x = sqrt( cndnum ) - 1 / sqrt( cndnum )
337 IF( n.GT.2 ) THEN
338 y = sqrt( 2. / ( n-2 ) )*x
339 ELSE
340 y = zero
341 END IF
342 z = x*x
343*
344 IF( upper ) THEN
345 IF( n.GT.3 ) THEN
346 CALL scopy( n-3, work, 1, a( 2, 3 ), lda+1 )
347 IF( n.GT.4 )
348 $ CALL scopy( n-4, work( n+1 ), 1, a( 2, 4 ), lda+1 )
349 END IF
350 DO 100 j = 2, n - 1
351 a( 1, j ) = y
352 a( j, n ) = y
353 100 CONTINUE
354 a( 1, n ) = z
355 ELSE
356 IF( n.GT.3 ) THEN
357 CALL scopy( n-3, work, 1, a( 3, 2 ), lda+1 )
358 IF( n.GT.4 )
359 $ CALL scopy( n-4, work( n+1 ), 1, a( 4, 2 ), lda+1 )
360 END IF
361 DO 110 j = 2, n - 1
362 a( j, 1 ) = y
363 a( n, j ) = y
364 110 CONTINUE
365 a( n, 1 ) = z
366 END IF
367*
368* Fill in the zeros using Givens rotations.
369*
370 IF( upper ) THEN
371 DO 120 j = 1, n - 1
372 ra = a( j, j+1 )
373 rb = 2.0
374 CALL srotg( ra, rb, c, s )
375*
376* Multiply by [ c s; -s c] on the left.
377*
378 IF( n.GT.j+1 )
379 $ CALL srot( n-j-1, a( j, j+2 ), lda, a( j+1, j+2 ),
380 $ lda, c, s )
381*
382* Multiply by [-c -s; s -c] on the right.
383*
384 IF( j.GT.1 )
385 $ CALL srot( j-1, a( 1, j+1 ), 1, a( 1, j ), 1, -c, -s )
386*
387* Negate A(J,J+1).
388*
389 a( j, j+1 ) = -a( j, j+1 )
390 120 CONTINUE
391 ELSE
392 DO 130 j = 1, n - 1
393 ra = a( j+1, j )
394 rb = 2.0
395 CALL srotg( ra, rb, c, s )
396*
397* Multiply by [ c -s; s c] on the right.
398*
399 IF( n.GT.j+1 )
400 $ CALL srot( n-j-1, a( j+2, j+1 ), 1, a( j+2, j ), 1, c,
401 $ -s )
402*
403* Multiply by [-c s; -s -c] on the left.
404*
405 IF( j.GT.1 )
406 $ CALL srot( j-1, a( j, 1 ), lda, a( j+1, 1 ), lda, -c,
407 $ s )
408*
409* Negate A(J+1,J).
410*
411 a( j+1, j ) = -a( j+1, j )
412 130 CONTINUE
413 END IF
414*
415* IMAT > 10: Pathological test cases. These triangular matrices
416* are badly scaled or badly conditioned, so when used in solving a
417* triangular system they may cause overflow in the solution vector.
418*
419 ELSE IF( imat.EQ.11 ) THEN
420*
421* Type 11: Generate a triangular matrix with elements between
422* -1 and 1. Give the diagonal norm 2 to make it well-conditioned.
423* Make the right hand side large so that it requires scaling.
424*
425 IF( upper ) THEN
426 DO 140 j = 1, n
427 CALL slarnv( 2, iseed, j, a( 1, j ) )
428 a( j, j ) = sign( two, a( j, j ) )
429 140 CONTINUE
430 ELSE
431 DO 150 j = 1, n
432 CALL slarnv( 2, iseed, n-j+1, a( j, j ) )
433 a( j, j ) = sign( two, a( j, j ) )
434 150 CONTINUE
435 END IF
436*
437* Set the right hand side so that the largest value is BIGNUM.
438*
439 CALL slarnv( 2, iseed, n, b )
440 iy = isamax( n, b, 1 )
441 bnorm = abs( b( iy ) )
442 bscal = bignum / max( one, bnorm )
443 CALL sscal( n, bscal, b, 1 )
444*
445 ELSE IF( imat.EQ.12 ) THEN
446*
447* Type 12: Make the first diagonal element in the solve small to
448* cause immediate overflow when dividing by T(j,j).
449* In type 12, the offdiagonal elements are small (CNORM(j) < 1).
450*
451 CALL slarnv( 2, iseed, n, b )
452 tscal = one / max( one, real( n-1 ) )
453 IF( upper ) THEN
454 DO 160 j = 1, n
455 CALL slarnv( 2, iseed, j, a( 1, j ) )
456 CALL sscal( j-1, tscal, a( 1, j ), 1 )
457 a( j, j ) = sign( one, a( j, j ) )
458 160 CONTINUE
459 a( n, n ) = smlnum*a( n, n )
460 ELSE
461 DO 170 j = 1, n
462 CALL slarnv( 2, iseed, n-j+1, a( j, j ) )
463 IF( n.GT.j )
464 $ CALL sscal( n-j, tscal, a( j+1, j ), 1 )
465 a( j, j ) = sign( one, a( j, j ) )
466 170 CONTINUE
467 a( 1, 1 ) = smlnum*a( 1, 1 )
468 END IF
469*
470 ELSE IF( imat.EQ.13 ) THEN
471*
472* Type 13: Make the first diagonal element in the solve small to
473* cause immediate overflow when dividing by T(j,j).
474* In type 13, the offdiagonal elements are O(1) (CNORM(j) > 1).
475*
476 CALL slarnv( 2, iseed, n, b )
477 IF( upper ) THEN
478 DO 180 j = 1, n
479 CALL slarnv( 2, iseed, j, a( 1, j ) )
480 a( j, j ) = sign( one, a( j, j ) )
481 180 CONTINUE
482 a( n, n ) = smlnum*a( n, n )
483 ELSE
484 DO 190 j = 1, n
485 CALL slarnv( 2, iseed, n-j+1, a( j, j ) )
486 a( j, j ) = sign( one, a( j, j ) )
487 190 CONTINUE
488 a( 1, 1 ) = smlnum*a( 1, 1 )
489 END IF
490*
491 ELSE IF( imat.EQ.14 ) THEN
492*
493* Type 14: T is diagonal with small numbers on the diagonal to
494* make the growth factor underflow, but a small right hand side
495* chosen so that the solution does not overflow.
496*
497 IF( upper ) THEN
498 jcount = 1
499 DO 210 j = n, 1, -1
500 DO 200 i = 1, j - 1
501 a( i, j ) = zero
502 200 CONTINUE
503 IF( jcount.LE.2 ) THEN
504 a( j, j ) = smlnum
505 ELSE
506 a( j, j ) = one
507 END IF
508 jcount = jcount + 1
509 IF( jcount.GT.4 )
510 $ jcount = 1
511 210 CONTINUE
512 ELSE
513 jcount = 1
514 DO 230 j = 1, n
515 DO 220 i = j + 1, n
516 a( i, j ) = zero
517 220 CONTINUE
518 IF( jcount.LE.2 ) THEN
519 a( j, j ) = smlnum
520 ELSE
521 a( j, j ) = one
522 END IF
523 jcount = jcount + 1
524 IF( jcount.GT.4 )
525 $ jcount = 1
526 230 CONTINUE
527 END IF
528*
529* Set the right hand side alternately zero and small.
530*
531 IF( upper ) THEN
532 b( 1 ) = zero
533 DO 240 i = n, 2, -2
534 b( i ) = zero
535 b( i-1 ) = smlnum
536 240 CONTINUE
537 ELSE
538 b( n ) = zero
539 DO 250 i = 1, n - 1, 2
540 b( i ) = zero
541 b( i+1 ) = smlnum
542 250 CONTINUE
543 END IF
544*
545 ELSE IF( imat.EQ.15 ) THEN
546*
547* Type 15: Make the diagonal elements small to cause gradual
548* overflow when dividing by T(j,j). To control the amount of
549* scaling needed, the matrix is bidiagonal.
550*
551 texp = one / max( one, real( n-1 ) )
552 tscal = smlnum**texp
553 CALL slarnv( 2, iseed, n, b )
554 IF( upper ) THEN
555 DO 270 j = 1, n
556 DO 260 i = 1, j - 2
557 a( i, j ) = 0.
558 260 CONTINUE
559 IF( j.GT.1 )
560 $ a( j-1, j ) = -one
561 a( j, j ) = tscal
562 270 CONTINUE
563 b( n ) = one
564 ELSE
565 DO 290 j = 1, n
566 DO 280 i = j + 2, n
567 a( i, j ) = 0.
568 280 CONTINUE
569 IF( j.LT.n )
570 $ a( j+1, j ) = -one
571 a( j, j ) = tscal
572 290 CONTINUE
573 b( 1 ) = one
574 END IF
575*
576 ELSE IF( imat.EQ.16 ) THEN
577*
578* Type 16: One zero diagonal element.
579*
580 iy = n / 2 + 1
581 IF( upper ) THEN
582 DO 300 j = 1, n
583 CALL slarnv( 2, iseed, j, a( 1, j ) )
584 IF( j.NE.iy ) THEN
585 a( j, j ) = sign( two, a( j, j ) )
586 ELSE
587 a( j, j ) = zero
588 END IF
589 300 CONTINUE
590 ELSE
591 DO 310 j = 1, n
592 CALL slarnv( 2, iseed, n-j+1, a( j, j ) )
593 IF( j.NE.iy ) THEN
594 a( j, j ) = sign( two, a( j, j ) )
595 ELSE
596 a( j, j ) = zero
597 END IF
598 310 CONTINUE
599 END IF
600 CALL slarnv( 2, iseed, n, b )
601 CALL sscal( n, two, b, 1 )
602*
603 ELSE IF( imat.EQ.17 ) THEN
604*
605* Type 17: Make the offdiagonal elements large to cause overflow
606* when adding a column of T. In the non-transposed case, the
607* matrix is constructed to cause overflow when adding a column in
608* every other step.
609*
610 tscal = unfl / ulp
611 tscal = ( one-ulp ) / tscal
612 DO 330 j = 1, n
613 DO 320 i = 1, n
614 a( i, j ) = 0.
615 320 CONTINUE
616 330 CONTINUE
617 texp = one
618 IF( upper ) THEN
619 DO 340 j = n, 2, -2
620 a( 1, j ) = -tscal / real( n+1 )
621 a( j, j ) = one
622 b( j ) = texp*( one-ulp )
623 a( 1, j-1 ) = -( tscal / real( n+1 ) ) / real( n+2 )
624 a( j-1, j-1 ) = one
625 b( j-1 ) = texp*real( n*n+n-1 )
626 texp = texp*2.
627 340 CONTINUE
628 b( 1 ) = ( real( n+1 ) / real( n+2 ) )*tscal
629 ELSE
630 DO 350 j = 1, n - 1, 2
631 a( n, j ) = -tscal / real( n+1 )
632 a( j, j ) = one
633 b( j ) = texp*( one-ulp )
634 a( n, j+1 ) = -( tscal / real( n+1 ) ) / real( n+2 )
635 a( j+1, j+1 ) = one
636 b( j+1 ) = texp*real( n*n+n-1 )
637 texp = texp*2.
638 350 CONTINUE
639 b( n ) = ( real( n+1 ) / real( n+2 ) )*tscal
640 END IF
641*
642 ELSE IF( imat.EQ.18 ) THEN
643*
644* Type 18: Generate a unit triangular matrix with elements
645* between -1 and 1, and make the right hand side large so that it
646* requires scaling.
647*
648 IF( upper ) THEN
649 DO 360 j = 1, n
650 CALL slarnv( 2, iseed, j-1, a( 1, j ) )
651 a( j, j ) = zero
652 360 CONTINUE
653 ELSE
654 DO 370 j = 1, n
655 IF( j.LT.n )
656 $ CALL slarnv( 2, iseed, n-j, a( j+1, j ) )
657 a( j, j ) = zero
658 370 CONTINUE
659 END IF
660*
661* Set the right hand side so that the largest value is BIGNUM.
662*
663 CALL slarnv( 2, iseed, n, b )
664 iy = isamax( n, b, 1 )
665 bnorm = abs( b( iy ) )
666 bscal = bignum / max( one, bnorm )
667 CALL sscal( n, bscal, b, 1 )
668*
669 ELSE IF( imat.EQ.19 ) THEN
670*
671* Type 19: Generate a triangular matrix with elements between
672* BIGNUM/(n-1) and BIGNUM so that at least one of the column
673* norms will exceed BIGNUM.
674* 1/3/91: SLATRS no longer can handle this case
675*
676 tleft = bignum / max( one, real( n-1 ) )
677 tscal = bignum*( real( n-1 ) / max( one, real( n ) ) )
678 IF( upper ) THEN
679 DO 390 j = 1, n
680 CALL slarnv( 2, iseed, j, a( 1, j ) )
681 DO 380 i = 1, j
682 a( i, j ) = sign( tleft, a( i, j ) ) + tscal*a( i, j )
683 380 CONTINUE
684 390 CONTINUE
685 ELSE
686 DO 410 j = 1, n
687 CALL slarnv( 2, iseed, n-j+1, a( j, j ) )
688 DO 400 i = j, n
689 a( i, j ) = sign( tleft, a( i, j ) ) + tscal*a( i, j )
690 400 CONTINUE
691 410 CONTINUE
692 END IF
693 CALL slarnv( 2, iseed, n, b )
694 CALL sscal( n, two, b, 1 )
695 END IF
696*
697* Flip the matrix if the transpose will be used.
698*
699 IF( .NOT.lsame( trans, 'N' ) ) THEN
700 IF( upper ) THEN
701 DO 420 j = 1, n / 2
702 CALL sswap( n-2*j+1, a( j, j ), lda, a( j+1, n-j+1 ),
703 $ -1 )
704 420 CONTINUE
705 ELSE
706 DO 430 j = 1, n / 2
707 CALL sswap( n-2*j+1, a( j, j ), 1, a( n-j+1, j+1 ),
708 $ -lda )
709 430 CONTINUE
710 END IF
711 END IF
712*
713 RETURN
714*
715* End of SLATTR
716*
subroutine scopy(n, sx, incx, sy, incy)
SCOPY
Definition scopy.f:82
integer function isamax(n, sx, incx)
ISAMAX
Definition isamax.f:71
real function slamch(cmach)
SLAMCH
Definition slamch.f:68
subroutine slarnv(idist, iseed, n, x)
SLARNV returns a vector of random numbers from a uniform or normal distribution.
Definition slarnv.f:97
logical function lsame(ca, cb)
LSAME
Definition lsame.f:48
subroutine srot(n, sx, incx, sy, incy, c, s)
SROT
Definition srot.f:92
subroutine srotg(a, b, c, s)
SROTG
Definition srotg.f90:92
subroutine sscal(n, sa, sx, incx)
SSCAL
Definition sscal.f:79
subroutine sswap(n, sx, incx, sy, incy)
SSWAP
Definition sswap.f:82
real function slarnd(idist, iseed)
SLARND
Definition slarnd.f:73
subroutine slatb4(path, imat, m, n, type, kl, ku, anorm, mode, cndnum, dist)
SLATB4
Definition slatb4.f:120
subroutine slatms(m, n, dist, iseed, sym, d, mode, cond, dmax, kl, ku, pack, a, lda, work, info)
SLATMS
Definition slatms.f:321
Here is the call graph for this function:
Here is the caller graph for this function: