LAPACK  3.10.0
LAPACK: Linear Algebra PACKage

◆ clatmr()

subroutine clatmr ( integer  M,
integer  N,
character  DIST,
integer, dimension( 4 )  ISEED,
character  SYM,
complex, dimension( * )  D,
integer  MODE,
real  COND,
complex  DMAX,
character  RSIGN,
character  GRADE,
complex, dimension( * )  DL,
integer  MODEL,
real  CONDL,
complex, dimension( * )  DR,
integer  MODER,
real  CONDR,
character  PIVTNG,
integer, dimension( * )  IPIVOT,
integer  KL,
integer  KU,
real  SPARSE,
real  ANORM,
character  PACK,
complex, dimension( lda, * )  A,
integer  LDA,
integer, dimension( * )  IWORK,
integer  INFO 
)

CLATMR

Purpose:
    CLATMR generates random matrices of various types for testing
    LAPACK programs.

    CLATMR operates by applying the following sequence of
    operations:

      Generate a matrix A with random entries of distribution DIST
         which is symmetric if SYM='S', Hermitian if SYM='H', and
         nonsymmetric if SYM='N'.

      Set the diagonal to D, where D may be input or
         computed according to MODE, COND, DMAX and RSIGN
         as described below.

      Grade the matrix, if desired, from the left and/or right
         as specified by GRADE. The inputs DL, MODEL, CONDL, DR,
         MODER and CONDR also determine the grading as described
         below.

      Permute, if desired, the rows and/or columns as specified by
         PIVTNG and IPIVOT.

      Set random entries to zero, if desired, to get a random sparse
         matrix as specified by SPARSE.

      Make A a band matrix, if desired, by zeroing out the matrix
         outside a band of lower bandwidth KL and upper bandwidth KU.

      Scale A, if desired, to have maximum entry ANORM.

      Pack the matrix if desired. Options specified by PACK are:
         no packing
         zero out upper half (if symmetric or Hermitian)
         zero out lower half (if symmetric or Hermitian)
         store the upper half columnwise (if symmetric or Hermitian
             or square upper triangular)
         store the lower half columnwise (if symmetric or Hermitian
             or square lower triangular)
             same as upper half rowwise if symmetric
             same as conjugate upper half rowwise if Hermitian
         store the lower triangle in banded format
             (if symmetric or Hermitian)
         store the upper triangle in banded format
             (if symmetric or Hermitian)
         store the entire matrix in banded format

    Note: If two calls to CLATMR differ only in the PACK parameter,
          they will generate mathematically equivalent matrices.

          If two calls to CLATMR both have full bandwidth (KL = M-1
          and KU = N-1), and differ only in the PIVTNG and PACK
          parameters, then the matrices generated will differ only
          in the order of the rows and/or columns, and otherwise
          contain the same data. This consistency cannot be and
          is not maintained with less than full bandwidth.
Parameters
[in]M
          M is INTEGER
           Number of rows of A. Not modified.
[in]N
          N is INTEGER
           Number of columns of A. Not modified.
[in]DIST
          DIST is CHARACTER*1
           On entry, DIST specifies the type of distribution to be used
           to generate a random matrix .
           'U' => real and imaginary parts are independent
                  UNIFORM( 0, 1 )  ( 'U' for uniform )
           'S' => real and imaginary parts are independent
                  UNIFORM( -1, 1 ) ( 'S' for symmetric )
           'N' => real and imaginary parts are independent
                  NORMAL( 0, 1 )   ( 'N' for normal )
           'D' => uniform on interior of unit disk ( 'D' for disk )
           Not modified.
[in,out]ISEED
          ISEED is INTEGER array, dimension (4)
           On entry ISEED specifies the seed of the random number
           generator. They should lie between 0 and 4095 inclusive,
           and ISEED(4) should 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 CLATMR
           to continue the same random number sequence.
           Changed on exit.
[in]SYM
          SYM is CHARACTER*1
           If SYM='S', generated matrix is symmetric.
           If SYM='H', generated matrix is Hermitian.
           If SYM='N', generated matrix is nonsymmetric.
           Not modified.
[in,out]D
          D is COMPLEX array, dimension (min(M,N))
           On entry this array specifies the diagonal entries
           of the diagonal of A.  D may either be specified
           on entry, or set according to MODE and COND as described
           below. If the matrix is Hermitian, the real part of D
           will be taken. May be changed on exit if MODE is nonzero.
[in]MODE
          MODE is INTEGER
           On entry describes how D is to be used:
           MODE = 0 means use D as input
           MODE = 1 sets D(1)=1 and D(2:N)=1.0/COND
           MODE = 2 sets D(1:N-1)=1 and D(N)=1.0/COND
           MODE = 3 sets D(I)=COND**(-(I-1)/(N-1))
           MODE = 4 sets D(i)=1 - (i-1)/(N-1)*(1 - 1/COND)
           MODE = 5 sets D to random numbers in the range
                    ( 1/COND , 1 ) such that their logarithms
                    are uniformly distributed.
           MODE = 6 set D to random numbers from same distribution
                    as the rest of the matrix.
           MODE < 0 has the same meaning as ABS(MODE), except that
              the order of the elements of D is reversed.
           Thus if MODE is positive, D has entries ranging from
              1 to 1/COND, if negative, from 1/COND to 1,
           Not modified.
[in]COND
          COND is REAL
           On entry, used as described under MODE above.
           If used, it must be >= 1. Not modified.
[in]DMAX
          DMAX is COMPLEX
           If MODE neither -6, 0 nor 6, the diagonal is scaled by
           DMAX / max(abs(D(i))), so that maximum absolute entry
           of diagonal is abs(DMAX). If DMAX is complex (or zero),
           diagonal will be scaled by a complex number (or zero).
[in]RSIGN
          RSIGN is CHARACTER*1
           If MODE neither -6, 0 nor 6, specifies sign of diagonal
           as follows:
           'T' => diagonal entries are multiplied by a random complex
                  number uniformly distributed with absolute value 1
           'F' => diagonal unchanged
           Not modified.
[in]GRADE
          GRADE is CHARACTER*1
           Specifies grading of matrix as follows:
           'N'  => no grading
           'L'  => matrix premultiplied by diag( DL )
                   (only if matrix nonsymmetric)
           'R'  => matrix postmultiplied by diag( DR )
                   (only if matrix nonsymmetric)
           'B'  => matrix premultiplied by diag( DL ) and
                         postmultiplied by diag( DR )
                   (only if matrix nonsymmetric)
           'H'  => matrix premultiplied by diag( DL ) and
                         postmultiplied by diag( CONJG(DL) )
                   (only if matrix Hermitian or nonsymmetric)
           'S'  => matrix premultiplied by diag( DL ) and
                         postmultiplied by diag( DL )
                   (only if matrix symmetric or nonsymmetric)
           'E'  => matrix premultiplied by diag( DL ) and
                         postmultiplied by inv( diag( DL ) )
                         ( 'S' for similarity )
                   (only if matrix nonsymmetric)
                   Note: if GRADE='S', then M must equal N.
           Not modified.
[in,out]DL
          DL is COMPLEX array, dimension (M)
           If MODEL=0, then on entry this array specifies the diagonal
           entries of a diagonal matrix used as described under GRADE
           above. If MODEL is not zero, then DL will be set according
           to MODEL and CONDL, analogous to the way D is set according
           to MODE and COND (except there is no DMAX parameter for DL).
           If GRADE='E', then DL cannot have zero entries.
           Not referenced if GRADE = 'N' or 'R'. Changed on exit.
[in]MODEL
          MODEL is INTEGER
           This specifies how the diagonal array DL is to be computed,
           just as MODE specifies how D is to be computed.
           Not modified.
[in]CONDL
          CONDL is REAL
           When MODEL is not zero, this specifies the condition number
           of the computed DL.  Not modified.
[in,out]DR
          DR is COMPLEX array, dimension (N)
           If MODER=0, then on entry this array specifies the diagonal
           entries of a diagonal matrix used as described under GRADE
           above. If MODER is not zero, then DR will be set according
           to MODER and CONDR, analogous to the way D is set according
           to MODE and COND (except there is no DMAX parameter for DR).
           Not referenced if GRADE = 'N', 'L', 'H' or 'S'.
           Changed on exit.
[in]MODER
          MODER is INTEGER
           This specifies how the diagonal array DR is to be computed,
           just as MODE specifies how D is to be computed.
           Not modified.
[in]CONDR
          CONDR is REAL
           When MODER is not zero, this specifies the condition number
           of the computed DR.  Not modified.
[in]PIVTNG
          PIVTNG is CHARACTER*1
           On entry specifies pivoting permutations as follows:
           'N' or ' ' => none.
           'L' => left or row pivoting (matrix must be nonsymmetric).
           'R' => right or column pivoting (matrix must be
                  nonsymmetric).
           'B' or 'F' => both or full pivoting, i.e., on both sides.
                         In this case, M must equal N

           If two calls to CLATMR both have full bandwidth (KL = M-1
           and KU = N-1), and differ only in the PIVTNG and PACK
           parameters, then the matrices generated will differ only
           in the order of the rows and/or columns, and otherwise
           contain the same data. This consistency cannot be
           maintained with less than full bandwidth.
[in]IPIVOT
          IPIVOT is INTEGER array, dimension (N or M)
           This array specifies the permutation used.  After the
           basic matrix is generated, the rows, columns, or both
           are permuted.   If, say, row pivoting is selected, CLATMR
           starts with the *last* row and interchanges the M-th and
           IPIVOT(M)-th rows, then moves to the next-to-last row,
           interchanging the (M-1)-th and the IPIVOT(M-1)-th rows,
           and so on.  In terms of "2-cycles", the permutation is
           (1 IPIVOT(1)) (2 IPIVOT(2)) ... (M IPIVOT(M))
           where the rightmost cycle is applied first.  This is the
           *inverse* of the effect of pivoting in LINPACK.  The idea
           is that factoring (with pivoting) an identity matrix
           which has been inverse-pivoted in this way should
           result in a pivot vector identical to IPIVOT.
           Not referenced if PIVTNG = 'N'. Not modified.
[in]KL
          KL is INTEGER
           On entry specifies the lower bandwidth of the  matrix. For
           example, KL=0 implies upper triangular, KL=1 implies upper
           Hessenberg, and KL at least M-1 implies the matrix is not
           banded. Must equal KU if matrix is symmetric or Hermitian.
           Not modified.
[in]KU
          KU is INTEGER
           On entry specifies the upper bandwidth of the  matrix. For
           example, KU=0 implies lower triangular, KU=1 implies lower
           Hessenberg, and KU at least N-1 implies the matrix is not
           banded. Must equal KL if matrix is symmetric or Hermitian.
           Not modified.
[in]SPARSE
          SPARSE is REAL
           On entry specifies the sparsity of the matrix if a sparse
           matrix is to be generated. SPARSE should lie between
           0 and 1. To generate a sparse matrix, for each matrix entry
           a uniform ( 0, 1 ) random number x is generated and
           compared to SPARSE; if x is larger the matrix entry
           is unchanged and if x is smaller the entry is set
           to zero. Thus on the average a fraction SPARSE of the
           entries will be set to zero.
           Not modified.
[in]ANORM
          ANORM is REAL
           On entry specifies maximum entry of output matrix
           (output matrix will by multiplied by a constant so that
           its largest absolute entry equal ANORM)
           if ANORM is nonnegative. If ANORM is negative no scaling
           is done. Not modified.
[in]PACK
          PACK is CHARACTER*1
           On entry specifies packing of matrix as follows:
           'N' => no packing
           'U' => zero out all subdiagonal entries
                  (if symmetric or Hermitian)
           'L' => zero out all superdiagonal entries
                  (if symmetric or Hermitian)
           'C' => store the upper triangle columnwise
                  (only if matrix symmetric or Hermitian or
                   square upper triangular)
           'R' => store the lower triangle columnwise
                  (only if matrix symmetric or Hermitian or
                   square lower triangular)
                  (same as upper half rowwise if symmetric)
                  (same as conjugate upper half rowwise if Hermitian)
           'B' => store the lower triangle in band storage scheme
                  (only if matrix symmetric or Hermitian)
           'Q' => store the upper triangle in band storage scheme
                  (only if matrix symmetric or Hermitian)
           'Z' => store the entire matrix in band storage scheme
                      (pivoting can be provided for by using this
                      option to store A in the trailing rows of
                      the allocated storage)

           Using these options, the various LAPACK packed and banded
           storage schemes can be obtained:
           GB               - use 'Z'
           PB, HB or TB     - use 'B' or 'Q'
           PP, HP or TP     - use 'C' or 'R'

           If two calls to CLATMR differ only in the PACK parameter,
           they will generate mathematically equivalent matrices.
           Not modified.
[in,out]A
          A is COMPLEX array, dimension (LDA,N)
           On exit A is the desired test matrix. Only those
           entries of A which are significant on output
           will be referenced (even if A is in packed or band
           storage format). The 'unoccupied corners' of A in
           band format will be zeroed out.
[in]LDA
          LDA is INTEGER
           on entry LDA specifies the first dimension of A as
           declared in the calling program.
           If PACK='N', 'U' or 'L', LDA must be at least max ( 1, M ).
           If PACK='C' or 'R', LDA must be at least 1.
           If PACK='B', or 'Q', LDA must be MIN ( KU+1, N )
           If PACK='Z', LDA must be at least KUU+KLL+1, where
           KUU = MIN ( KU, N-1 ) and KLL = MIN ( KL, M-1 )
           Not modified.
[out]IWORK
          IWORK is INTEGER array, dimension (N or M)
           Workspace. Not referenced if PIVTNG = 'N'. Changed on exit.
[out]INFO
          INFO is INTEGER
           Error parameter on exit:
             0 => normal return
            -1 => M negative or unequal to N and SYM='S' or 'H'
            -2 => N negative
            -3 => DIST illegal string
            -5 => SYM illegal string
            -7 => MODE not in range -6 to 6
            -8 => COND less than 1.0, and MODE neither -6, 0 nor 6
           -10 => MODE neither -6, 0 nor 6 and RSIGN illegal string
           -11 => GRADE illegal string, or GRADE='E' and
                  M not equal to N, or GRADE='L', 'R', 'B', 'S' or 'E'
                  and SYM = 'H', or GRADE='L', 'R', 'B', 'H' or 'E'
                  and SYM = 'S'
           -12 => GRADE = 'E' and DL contains zero
           -13 => MODEL not in range -6 to 6 and GRADE= 'L', 'B', 'H',
                  'S' or 'E'
           -14 => CONDL less than 1.0, GRADE='L', 'B', 'H', 'S' or 'E',
                  and MODEL neither -6, 0 nor 6
           -16 => MODER not in range -6 to 6 and GRADE= 'R' or 'B'
           -17 => CONDR less than 1.0, GRADE='R' or 'B', and
                  MODER neither -6, 0 nor 6
           -18 => PIVTNG illegal string, or PIVTNG='B' or 'F' and
                  M not equal to N, or PIVTNG='L' or 'R' and SYM='S'
                  or 'H'
           -19 => IPIVOT contains out of range number and
                  PIVTNG not equal to 'N'
           -20 => KL negative
           -21 => KU negative, or SYM='S' or 'H' and KU not equal to KL
           -22 => SPARSE not in range 0. to 1.
           -24 => PACK illegal string, or PACK='U', 'L', 'B' or 'Q'
                  and SYM='N', or PACK='C' and SYM='N' and either KL
                  not equal to 0 or N not equal to M, or PACK='R' and
                  SYM='N', and either KU not equal to 0 or N not equal
                  to M
           -26 => LDA too small
             1 => Error return from CLATM1 (computing D)
             2 => Cannot scale diagonal to DMAX (max. entry is 0)
             3 => Error return from CLATM1 (computing DL)
             4 => Error return from CLATM1 (computing DR)
             5 => ANORM is positive, but matrix constructed prior to
                  attempting to scale it to have norm ANORM, is zero
Author
Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 486 of file clatmr.f.

490 *
491 * -- LAPACK computational routine --
492 * -- LAPACK is a software package provided by Univ. of Tennessee, --
493 * -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
494 *
495 * .. Scalar Arguments ..
496  CHARACTER DIST, GRADE, PACK, PIVTNG, RSIGN, SYM
497  INTEGER INFO, KL, KU, LDA, M, MODE, MODEL, MODER, N
498  REAL ANORM, COND, CONDL, CONDR, SPARSE
499  COMPLEX DMAX
500 * ..
501 * .. Array Arguments ..
502  INTEGER IPIVOT( * ), ISEED( 4 ), IWORK( * )
503  COMPLEX A( LDA, * ), D( * ), DL( * ), DR( * )
504 * ..
505 *
506 * =====================================================================
507 *
508 * .. Parameters ..
509  REAL ZERO
510  parameter( zero = 0.0e0 )
511  REAL ONE
512  parameter( one = 1.0e0 )
513  COMPLEX CONE
514  parameter( cone = ( 1.0e0, 0.0e0 ) )
515  COMPLEX CZERO
516  parameter( czero = ( 0.0e0, 0.0e0 ) )
517 * ..
518 * .. Local Scalars ..
519  LOGICAL BADPVT, DZERO, FULBND
520  INTEGER I, IDIST, IGRADE, IISUB, IPACK, IPVTNG, IRSIGN,
521  $ ISUB, ISYM, J, JJSUB, JSUB, K, KLL, KUU, MNMIN,
522  $ MNSUB, MXSUB, NPVTS
523  REAL ONORM, TEMP
524  COMPLEX CALPHA, CTEMP
525 * ..
526 * .. Local Arrays ..
527  REAL TEMPA( 1 )
528 * ..
529 * .. External Functions ..
530  LOGICAL LSAME
531  REAL CLANGB, CLANGE, CLANSB, CLANSP, CLANSY
532  COMPLEX CLATM2, CLATM3
533  EXTERNAL lsame, clangb, clange, clansb, clansp, clansy,
534  $ clatm2, clatm3
535 * ..
536 * .. External Subroutines ..
537  EXTERNAL clatm1, csscal, xerbla
538 * ..
539 * .. Intrinsic Functions ..
540  INTRINSIC abs, conjg, max, min, mod, real
541 * ..
542 * .. Executable Statements ..
543 *
544 * 1) Decode and Test the input parameters.
545 * Initialize flags & seed.
546 *
547  info = 0
548 *
549 * Quick return if possible
550 *
551  IF( m.EQ.0 .OR. n.EQ.0 )
552  $ RETURN
553 *
554 * Decode DIST
555 *
556  IF( lsame( dist, 'U' ) ) THEN
557  idist = 1
558  ELSE IF( lsame( dist, 'S' ) ) THEN
559  idist = 2
560  ELSE IF( lsame( dist, 'N' ) ) THEN
561  idist = 3
562  ELSE IF( lsame( dist, 'D' ) ) THEN
563  idist = 4
564  ELSE
565  idist = -1
566  END IF
567 *
568 * Decode SYM
569 *
570  IF( lsame( sym, 'H' ) ) THEN
571  isym = 0
572  ELSE IF( lsame( sym, 'N' ) ) THEN
573  isym = 1
574  ELSE IF( lsame( sym, 'S' ) ) THEN
575  isym = 2
576  ELSE
577  isym = -1
578  END IF
579 *
580 * Decode RSIGN
581 *
582  IF( lsame( rsign, 'F' ) ) THEN
583  irsign = 0
584  ELSE IF( lsame( rsign, 'T' ) ) THEN
585  irsign = 1
586  ELSE
587  irsign = -1
588  END IF
589 *
590 * Decode PIVTNG
591 *
592  IF( lsame( pivtng, 'N' ) ) THEN
593  ipvtng = 0
594  ELSE IF( lsame( pivtng, ' ' ) ) THEN
595  ipvtng = 0
596  ELSE IF( lsame( pivtng, 'L' ) ) THEN
597  ipvtng = 1
598  npvts = m
599  ELSE IF( lsame( pivtng, 'R' ) ) THEN
600  ipvtng = 2
601  npvts = n
602  ELSE IF( lsame( pivtng, 'B' ) ) THEN
603  ipvtng = 3
604  npvts = min( n, m )
605  ELSE IF( lsame( pivtng, 'F' ) ) THEN
606  ipvtng = 3
607  npvts = min( n, m )
608  ELSE
609  ipvtng = -1
610  END IF
611 *
612 * Decode GRADE
613 *
614  IF( lsame( grade, 'N' ) ) THEN
615  igrade = 0
616  ELSE IF( lsame( grade, 'L' ) ) THEN
617  igrade = 1
618  ELSE IF( lsame( grade, 'R' ) ) THEN
619  igrade = 2
620  ELSE IF( lsame( grade, 'B' ) ) THEN
621  igrade = 3
622  ELSE IF( lsame( grade, 'E' ) ) THEN
623  igrade = 4
624  ELSE IF( lsame( grade, 'H' ) ) THEN
625  igrade = 5
626  ELSE IF( lsame( grade, 'S' ) ) THEN
627  igrade = 6
628  ELSE
629  igrade = -1
630  END IF
631 *
632 * Decode PACK
633 *
634  IF( lsame( pack, 'N' ) ) THEN
635  ipack = 0
636  ELSE IF( lsame( pack, 'U' ) ) THEN
637  ipack = 1
638  ELSE IF( lsame( pack, 'L' ) ) THEN
639  ipack = 2
640  ELSE IF( lsame( pack, 'C' ) ) THEN
641  ipack = 3
642  ELSE IF( lsame( pack, 'R' ) ) THEN
643  ipack = 4
644  ELSE IF( lsame( pack, 'B' ) ) THEN
645  ipack = 5
646  ELSE IF( lsame( pack, 'Q' ) ) THEN
647  ipack = 6
648  ELSE IF( lsame( pack, 'Z' ) ) THEN
649  ipack = 7
650  ELSE
651  ipack = -1
652  END IF
653 *
654 * Set certain internal parameters
655 *
656  mnmin = min( m, n )
657  kll = min( kl, m-1 )
658  kuu = min( ku, n-1 )
659 *
660 * If inv(DL) is used, check to see if DL has a zero entry.
661 *
662  dzero = .false.
663  IF( igrade.EQ.4 .AND. model.EQ.0 ) THEN
664  DO 10 i = 1, m
665  IF( dl( i ).EQ.czero )
666  $ dzero = .true.
667  10 CONTINUE
668  END IF
669 *
670 * Check values in IPIVOT
671 *
672  badpvt = .false.
673  IF( ipvtng.GT.0 ) THEN
674  DO 20 j = 1, npvts
675  IF( ipivot( j ).LE.0 .OR. ipivot( j ).GT.npvts )
676  $ badpvt = .true.
677  20 CONTINUE
678  END IF
679 *
680 * Set INFO if an error
681 *
682  IF( m.LT.0 ) THEN
683  info = -1
684  ELSE IF( m.NE.n .AND. ( isym.EQ.0 .OR. isym.EQ.2 ) ) THEN
685  info = -1
686  ELSE IF( n.LT.0 ) THEN
687  info = -2
688  ELSE IF( idist.EQ.-1 ) THEN
689  info = -3
690  ELSE IF( isym.EQ.-1 ) THEN
691  info = -5
692  ELSE IF( mode.LT.-6 .OR. mode.GT.6 ) THEN
693  info = -7
694  ELSE IF( ( mode.NE.-6 .AND. mode.NE.0 .AND. mode.NE.6 ) .AND.
695  $ cond.LT.one ) THEN
696  info = -8
697  ELSE IF( ( mode.NE.-6 .AND. mode.NE.0 .AND. mode.NE.6 ) .AND.
698  $ irsign.EQ.-1 ) THEN
699  info = -10
700  ELSE IF( igrade.EQ.-1 .OR. ( igrade.EQ.4 .AND. m.NE.n ) .OR.
701  $ ( ( igrade.EQ.1 .OR. igrade.EQ.2 .OR. igrade.EQ.3 .OR.
702  $ igrade.EQ.4 .OR. igrade.EQ.6 ) .AND. isym.EQ.0 ) .OR.
703  $ ( ( igrade.EQ.1 .OR. igrade.EQ.2 .OR. igrade.EQ.3 .OR.
704  $ igrade.EQ.4 .OR. igrade.EQ.5 ) .AND. isym.EQ.2 ) ) THEN
705  info = -11
706  ELSE IF( igrade.EQ.4 .AND. dzero ) THEN
707  info = -12
708  ELSE IF( ( igrade.EQ.1 .OR. igrade.EQ.3 .OR. igrade.EQ.4 .OR.
709  $ igrade.EQ.5 .OR. igrade.EQ.6 ) .AND.
710  $ ( model.LT.-6 .OR. model.GT.6 ) ) THEN
711  info = -13
712  ELSE IF( ( igrade.EQ.1 .OR. igrade.EQ.3 .OR. igrade.EQ.4 .OR.
713  $ igrade.EQ.5 .OR. igrade.EQ.6 ) .AND.
714  $ ( model.NE.-6 .AND. model.NE.0 .AND. model.NE.6 ) .AND.
715  $ condl.LT.one ) THEN
716  info = -14
717  ELSE IF( ( igrade.EQ.2 .OR. igrade.EQ.3 ) .AND.
718  $ ( moder.LT.-6 .OR. moder.GT.6 ) ) THEN
719  info = -16
720  ELSE IF( ( igrade.EQ.2 .OR. igrade.EQ.3 ) .AND.
721  $ ( moder.NE.-6 .AND. moder.NE.0 .AND. moder.NE.6 ) .AND.
722  $ condr.LT.one ) THEN
723  info = -17
724  ELSE IF( ipvtng.EQ.-1 .OR. ( ipvtng.EQ.3 .AND. m.NE.n ) .OR.
725  $ ( ( ipvtng.EQ.1 .OR. ipvtng.EQ.2 ) .AND. ( isym.EQ.0 .OR.
726  $ isym.EQ.2 ) ) ) THEN
727  info = -18
728  ELSE IF( ipvtng.NE.0 .AND. badpvt ) THEN
729  info = -19
730  ELSE IF( kl.LT.0 ) THEN
731  info = -20
732  ELSE IF( ku.LT.0 .OR. ( ( isym.EQ.0 .OR. isym.EQ.2 ) .AND. kl.NE.
733  $ ku ) ) THEN
734  info = -21
735  ELSE IF( sparse.LT.zero .OR. sparse.GT.one ) THEN
736  info = -22
737  ELSE IF( ipack.EQ.-1 .OR. ( ( ipack.EQ.1 .OR. ipack.EQ.2 .OR.
738  $ ipack.EQ.5 .OR. ipack.EQ.6 ) .AND. isym.EQ.1 ) .OR.
739  $ ( ipack.EQ.3 .AND. isym.EQ.1 .AND. ( kl.NE.0 .OR. m.NE.
740  $ n ) ) .OR. ( ipack.EQ.4 .AND. isym.EQ.1 .AND. ( ku.NE.
741  $ 0 .OR. m.NE.n ) ) ) THEN
742  info = -24
743  ELSE IF( ( ( ipack.EQ.0 .OR. ipack.EQ.1 .OR. ipack.EQ.2 ) .AND.
744  $ lda.LT.max( 1, m ) ) .OR. ( ( ipack.EQ.3 .OR. ipack.EQ.
745  $ 4 ) .AND. lda.LT.1 ) .OR. ( ( ipack.EQ.5 .OR. ipack.EQ.
746  $ 6 ) .AND. lda.LT.kuu+1 ) .OR.
747  $ ( ipack.EQ.7 .AND. lda.LT.kll+kuu+1 ) ) THEN
748  info = -26
749  END IF
750 *
751  IF( info.NE.0 ) THEN
752  CALL xerbla( 'CLATMR', -info )
753  RETURN
754  END IF
755 *
756 * Decide if we can pivot consistently
757 *
758  fulbnd = .false.
759  IF( kuu.EQ.n-1 .AND. kll.EQ.m-1 )
760  $ fulbnd = .true.
761 *
762 * Initialize random number generator
763 *
764  DO 30 i = 1, 4
765  iseed( i ) = mod( abs( iseed( i ) ), 4096 )
766  30 CONTINUE
767 *
768  iseed( 4 ) = 2*( iseed( 4 ) / 2 ) + 1
769 *
770 * 2) Set up D, DL, and DR, if indicated.
771 *
772 * Compute D according to COND and MODE
773 *
774  CALL clatm1( mode, cond, irsign, idist, iseed, d, mnmin, info )
775  IF( info.NE.0 ) THEN
776  info = 1
777  RETURN
778  END IF
779  IF( mode.NE.0 .AND. mode.NE.-6 .AND. mode.NE.6 ) THEN
780 *
781 * Scale by DMAX
782 *
783  temp = abs( d( 1 ) )
784  DO 40 i = 2, mnmin
785  temp = max( temp, abs( d( i ) ) )
786  40 CONTINUE
787  IF( temp.EQ.zero .AND. dmax.NE.czero ) THEN
788  info = 2
789  RETURN
790  END IF
791  IF( temp.NE.zero ) THEN
792  calpha = dmax / temp
793  ELSE
794  calpha = cone
795  END IF
796  DO 50 i = 1, mnmin
797  d( i ) = calpha*d( i )
798  50 CONTINUE
799 *
800  END IF
801 *
802 * If matrix Hermitian, make D real
803 *
804  IF( isym.EQ.0 ) THEN
805  DO 60 i = 1, mnmin
806  d( i ) = real( d( i ) )
807  60 CONTINUE
808  END IF
809 *
810 * Compute DL if grading set
811 *
812  IF( igrade.EQ.1 .OR. igrade.EQ.3 .OR. igrade.EQ.4 .OR. igrade.EQ.
813  $ 5 .OR. igrade.EQ.6 ) THEN
814  CALL clatm1( model, condl, 0, idist, iseed, dl, m, info )
815  IF( info.NE.0 ) THEN
816  info = 3
817  RETURN
818  END IF
819  END IF
820 *
821 * Compute DR if grading set
822 *
823  IF( igrade.EQ.2 .OR. igrade.EQ.3 ) THEN
824  CALL clatm1( moder, condr, 0, idist, iseed, dr, n, info )
825  IF( info.NE.0 ) THEN
826  info = 4
827  RETURN
828  END IF
829  END IF
830 *
831 * 3) Generate IWORK if pivoting
832 *
833  IF( ipvtng.GT.0 ) THEN
834  DO 70 i = 1, npvts
835  iwork( i ) = i
836  70 CONTINUE
837  IF( fulbnd ) THEN
838  DO 80 i = 1, npvts
839  k = ipivot( i )
840  j = iwork( i )
841  iwork( i ) = iwork( k )
842  iwork( k ) = j
843  80 CONTINUE
844  ELSE
845  DO 90 i = npvts, 1, -1
846  k = ipivot( i )
847  j = iwork( i )
848  iwork( i ) = iwork( k )
849  iwork( k ) = j
850  90 CONTINUE
851  END IF
852  END IF
853 *
854 * 4) Generate matrices for each kind of PACKing
855 * Always sweep matrix columnwise (if symmetric, upper
856 * half only) so that matrix generated does not depend
857 * on PACK
858 *
859  IF( fulbnd ) THEN
860 *
861 * Use CLATM3 so matrices generated with differing PIVOTing only
862 * differ only in the order of their rows and/or columns.
863 *
864  IF( ipack.EQ.0 ) THEN
865  IF( isym.EQ.0 ) THEN
866  DO 110 j = 1, n
867  DO 100 i = 1, j
868  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku,
869  $ idist, iseed, d, igrade, dl, dr, ipvtng,
870  $ iwork, sparse )
871  a( isub, jsub ) = ctemp
872  a( jsub, isub ) = conjg( ctemp )
873  100 CONTINUE
874  110 CONTINUE
875  ELSE IF( isym.EQ.1 ) THEN
876  DO 130 j = 1, n
877  DO 120 i = 1, m
878  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku,
879  $ idist, iseed, d, igrade, dl, dr, ipvtng,
880  $ iwork, sparse )
881  a( isub, jsub ) = ctemp
882  120 CONTINUE
883  130 CONTINUE
884  ELSE IF( isym.EQ.2 ) THEN
885  DO 150 j = 1, n
886  DO 140 i = 1, j
887  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku,
888  $ idist, iseed, d, igrade, dl, dr, ipvtng,
889  $ iwork, sparse )
890  a( isub, jsub ) = ctemp
891  a( jsub, isub ) = ctemp
892  140 CONTINUE
893  150 CONTINUE
894  END IF
895 *
896  ELSE IF( ipack.EQ.1 ) THEN
897 *
898  DO 170 j = 1, n
899  DO 160 i = 1, j
900  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku, idist,
901  $ iseed, d, igrade, dl, dr, ipvtng, iwork,
902  $ sparse )
903  mnsub = min( isub, jsub )
904  mxsub = max( isub, jsub )
905  IF( mxsub.EQ.isub .AND. isym.EQ.0 ) THEN
906  a( mnsub, mxsub ) = conjg( ctemp )
907  ELSE
908  a( mnsub, mxsub ) = ctemp
909  END IF
910  IF( mnsub.NE.mxsub )
911  $ a( mxsub, mnsub ) = czero
912  160 CONTINUE
913  170 CONTINUE
914 *
915  ELSE IF( ipack.EQ.2 ) THEN
916 *
917  DO 190 j = 1, n
918  DO 180 i = 1, j
919  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku, idist,
920  $ iseed, d, igrade, dl, dr, ipvtng, iwork,
921  $ sparse )
922  mnsub = min( isub, jsub )
923  mxsub = max( isub, jsub )
924  IF( mxsub.EQ.jsub .AND. isym.EQ.0 ) THEN
925  a( mxsub, mnsub ) = conjg( ctemp )
926  ELSE
927  a( mxsub, mnsub ) = ctemp
928  END IF
929  IF( mnsub.NE.mxsub )
930  $ a( mnsub, mxsub ) = czero
931  180 CONTINUE
932  190 CONTINUE
933 *
934  ELSE IF( ipack.EQ.3 ) THEN
935 *
936  DO 210 j = 1, n
937  DO 200 i = 1, j
938  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku, idist,
939  $ iseed, d, igrade, dl, dr, ipvtng, iwork,
940  $ sparse )
941 *
942 * Compute K = location of (ISUB,JSUB) entry in packed
943 * array
944 *
945  mnsub = min( isub, jsub )
946  mxsub = max( isub, jsub )
947  k = mxsub*( mxsub-1 ) / 2 + mnsub
948 *
949 * Convert K to (IISUB,JJSUB) location
950 *
951  jjsub = ( k-1 ) / lda + 1
952  iisub = k - lda*( jjsub-1 )
953 *
954  IF( mxsub.EQ.isub .AND. isym.EQ.0 ) THEN
955  a( iisub, jjsub ) = conjg( ctemp )
956  ELSE
957  a( iisub, jjsub ) = ctemp
958  END IF
959  200 CONTINUE
960  210 CONTINUE
961 *
962  ELSE IF( ipack.EQ.4 ) THEN
963 *
964  DO 230 j = 1, n
965  DO 220 i = 1, j
966  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku, idist,
967  $ iseed, d, igrade, dl, dr, ipvtng, iwork,
968  $ sparse )
969 *
970 * Compute K = location of (I,J) entry in packed array
971 *
972  mnsub = min( isub, jsub )
973  mxsub = max( isub, jsub )
974  IF( mnsub.EQ.1 ) THEN
975  k = mxsub
976  ELSE
977  k = n*( n+1 ) / 2 - ( n-mnsub+1 )*( n-mnsub+2 ) /
978  $ 2 + mxsub - mnsub + 1
979  END IF
980 *
981 * Convert K to (IISUB,JJSUB) location
982 *
983  jjsub = ( k-1 ) / lda + 1
984  iisub = k - lda*( jjsub-1 )
985 *
986  IF( mxsub.EQ.jsub .AND. isym.EQ.0 ) THEN
987  a( iisub, jjsub ) = conjg( ctemp )
988  ELSE
989  a( iisub, jjsub ) = ctemp
990  END IF
991  220 CONTINUE
992  230 CONTINUE
993 *
994  ELSE IF( ipack.EQ.5 ) THEN
995 *
996  DO 250 j = 1, n
997  DO 240 i = j - kuu, j
998  IF( i.LT.1 ) THEN
999  a( j-i+1, i+n ) = czero
1000  ELSE
1001  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku,
1002  $ idist, iseed, d, igrade, dl, dr, ipvtng,
1003  $ iwork, sparse )
1004  mnsub = min( isub, jsub )
1005  mxsub = max( isub, jsub )
1006  IF( mxsub.EQ.jsub .AND. isym.EQ.0 ) THEN
1007  a( mxsub-mnsub+1, mnsub ) = conjg( ctemp )
1008  ELSE
1009  a( mxsub-mnsub+1, mnsub ) = ctemp
1010  END IF
1011  END IF
1012  240 CONTINUE
1013  250 CONTINUE
1014 *
1015  ELSE IF( ipack.EQ.6 ) THEN
1016 *
1017  DO 270 j = 1, n
1018  DO 260 i = j - kuu, j
1019  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku, idist,
1020  $ iseed, d, igrade, dl, dr, ipvtng, iwork,
1021  $ sparse )
1022  mnsub = min( isub, jsub )
1023  mxsub = max( isub, jsub )
1024  IF( mxsub.EQ.isub .AND. isym.EQ.0 ) THEN
1025  a( mnsub-mxsub+kuu+1, mxsub ) = conjg( ctemp )
1026  ELSE
1027  a( mnsub-mxsub+kuu+1, mxsub ) = ctemp
1028  END IF
1029  260 CONTINUE
1030  270 CONTINUE
1031 *
1032  ELSE IF( ipack.EQ.7 ) THEN
1033 *
1034  IF( isym.NE.1 ) THEN
1035  DO 290 j = 1, n
1036  DO 280 i = j - kuu, j
1037  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku,
1038  $ idist, iseed, d, igrade, dl, dr, ipvtng,
1039  $ iwork, sparse )
1040  mnsub = min( isub, jsub )
1041  mxsub = max( isub, jsub )
1042  IF( i.LT.1 )
1043  $ a( j-i+1+kuu, i+n ) = czero
1044  IF( mxsub.EQ.isub .AND. isym.EQ.0 ) THEN
1045  a( mnsub-mxsub+kuu+1, mxsub ) = conjg( ctemp )
1046  ELSE
1047  a( mnsub-mxsub+kuu+1, mxsub ) = ctemp
1048  END IF
1049  IF( i.GE.1 .AND. mnsub.NE.mxsub ) THEN
1050  IF( mnsub.EQ.isub .AND. isym.EQ.0 ) THEN
1051  a( mxsub-mnsub+1+kuu,
1052  $ mnsub ) = conjg( ctemp )
1053  ELSE
1054  a( mxsub-mnsub+1+kuu, mnsub ) = ctemp
1055  END IF
1056  END IF
1057  280 CONTINUE
1058  290 CONTINUE
1059  ELSE IF( isym.EQ.1 ) THEN
1060  DO 310 j = 1, n
1061  DO 300 i = j - kuu, j + kll
1062  ctemp = clatm3( m, n, i, j, isub, jsub, kl, ku,
1063  $ idist, iseed, d, igrade, dl, dr, ipvtng,
1064  $ iwork, sparse )
1065  a( isub-jsub+kuu+1, jsub ) = ctemp
1066  300 CONTINUE
1067  310 CONTINUE
1068  END IF
1069 *
1070  END IF
1071 *
1072  ELSE
1073 *
1074 * Use CLATM2
1075 *
1076  IF( ipack.EQ.0 ) THEN
1077  IF( isym.EQ.0 ) THEN
1078  DO 330 j = 1, n
1079  DO 320 i = 1, j
1080  a( i, j ) = clatm2( m, n, i, j, kl, ku, idist,
1081  $ iseed, d, igrade, dl, dr, ipvtng,
1082  $ iwork, sparse )
1083  a( j, i ) = conjg( a( i, j ) )
1084  320 CONTINUE
1085  330 CONTINUE
1086  ELSE IF( isym.EQ.1 ) THEN
1087  DO 350 j = 1, n
1088  DO 340 i = 1, m
1089  a( i, j ) = clatm2( m, n, i, j, kl, ku, idist,
1090  $ iseed, d, igrade, dl, dr, ipvtng,
1091  $ iwork, sparse )
1092  340 CONTINUE
1093  350 CONTINUE
1094  ELSE IF( isym.EQ.2 ) THEN
1095  DO 370 j = 1, n
1096  DO 360 i = 1, j
1097  a( i, j ) = clatm2( m, n, i, j, kl, ku, idist,
1098  $ iseed, d, igrade, dl, dr, ipvtng,
1099  $ iwork, sparse )
1100  a( j, i ) = a( i, j )
1101  360 CONTINUE
1102  370 CONTINUE
1103  END IF
1104 *
1105  ELSE IF( ipack.EQ.1 ) THEN
1106 *
1107  DO 390 j = 1, n
1108  DO 380 i = 1, j
1109  a( i, j ) = clatm2( m, n, i, j, kl, ku, idist, iseed,
1110  $ d, igrade, dl, dr, ipvtng, iwork, sparse )
1111  IF( i.NE.j )
1112  $ a( j, i ) = czero
1113  380 CONTINUE
1114  390 CONTINUE
1115 *
1116  ELSE IF( ipack.EQ.2 ) THEN
1117 *
1118  DO 410 j = 1, n
1119  DO 400 i = 1, j
1120  IF( isym.EQ.0 ) THEN
1121  a( j, i ) = conjg( clatm2( m, n, i, j, kl, ku,
1122  $ idist, iseed, d, igrade, dl, dr,
1123  $ ipvtng, iwork, sparse ) )
1124  ELSE
1125  a( j, i ) = clatm2( m, n, i, j, kl, ku, idist,
1126  $ iseed, d, igrade, dl, dr, ipvtng,
1127  $ iwork, sparse )
1128  END IF
1129  IF( i.NE.j )
1130  $ a( i, j ) = czero
1131  400 CONTINUE
1132  410 CONTINUE
1133 *
1134  ELSE IF( ipack.EQ.3 ) THEN
1135 *
1136  isub = 0
1137  jsub = 1
1138  DO 430 j = 1, n
1139  DO 420 i = 1, j
1140  isub = isub + 1
1141  IF( isub.GT.lda ) THEN
1142  isub = 1
1143  jsub = jsub + 1
1144  END IF
1145  a( isub, jsub ) = clatm2( m, n, i, j, kl, ku, idist,
1146  $ iseed, d, igrade, dl, dr, ipvtng,
1147  $ iwork, sparse )
1148  420 CONTINUE
1149  430 CONTINUE
1150 *
1151  ELSE IF( ipack.EQ.4 ) THEN
1152 *
1153  IF( isym.EQ.0 .OR. isym.EQ.2 ) THEN
1154  DO 450 j = 1, n
1155  DO 440 i = 1, j
1156 *
1157 * Compute K = location of (I,J) entry in packed array
1158 *
1159  IF( i.EQ.1 ) THEN
1160  k = j
1161  ELSE
1162  k = n*( n+1 ) / 2 - ( n-i+1 )*( n-i+2 ) / 2 +
1163  $ j - i + 1
1164  END IF
1165 *
1166 * Convert K to (ISUB,JSUB) location
1167 *
1168  jsub = ( k-1 ) / lda + 1
1169  isub = k - lda*( jsub-1 )
1170 *
1171  a( isub, jsub ) = clatm2( m, n, i, j, kl, ku,
1172  $ idist, iseed, d, igrade, dl, dr,
1173  $ ipvtng, iwork, sparse )
1174  IF( isym.EQ.0 )
1175  $ a( isub, jsub ) = conjg( a( isub, jsub ) )
1176  440 CONTINUE
1177  450 CONTINUE
1178  ELSE
1179  isub = 0
1180  jsub = 1
1181  DO 470 j = 1, n
1182  DO 460 i = j, m
1183  isub = isub + 1
1184  IF( isub.GT.lda ) THEN
1185  isub = 1
1186  jsub = jsub + 1
1187  END IF
1188  a( isub, jsub ) = clatm2( m, n, i, j, kl, ku,
1189  $ idist, iseed, d, igrade, dl, dr,
1190  $ ipvtng, iwork, sparse )
1191  460 CONTINUE
1192  470 CONTINUE
1193  END IF
1194 *
1195  ELSE IF( ipack.EQ.5 ) THEN
1196 *
1197  DO 490 j = 1, n
1198  DO 480 i = j - kuu, j
1199  IF( i.LT.1 ) THEN
1200  a( j-i+1, i+n ) = czero
1201  ELSE
1202  IF( isym.EQ.0 ) THEN
1203  a( j-i+1, i ) = conjg( clatm2( m, n, i, j, kl,
1204  $ ku, idist, iseed, d, igrade, dl,
1205  $ dr, ipvtng, iwork, sparse ) )
1206  ELSE
1207  a( j-i+1, i ) = clatm2( m, n, i, j, kl, ku,
1208  $ idist, iseed, d, igrade, dl, dr,
1209  $ ipvtng, iwork, sparse )
1210  END IF
1211  END IF
1212  480 CONTINUE
1213  490 CONTINUE
1214 *
1215  ELSE IF( ipack.EQ.6 ) THEN
1216 *
1217  DO 510 j = 1, n
1218  DO 500 i = j - kuu, j
1219  a( i-j+kuu+1, j ) = clatm2( m, n, i, j, kl, ku, idist,
1220  $ iseed, d, igrade, dl, dr, ipvtng,
1221  $ iwork, sparse )
1222  500 CONTINUE
1223  510 CONTINUE
1224 *
1225  ELSE IF( ipack.EQ.7 ) THEN
1226 *
1227  IF( isym.NE.1 ) THEN
1228  DO 530 j = 1, n
1229  DO 520 i = j - kuu, j
1230  a( i-j+kuu+1, j ) = clatm2( m, n, i, j, kl, ku,
1231  $ idist, iseed, d, igrade, dl,
1232  $ dr, ipvtng, iwork, sparse )
1233  IF( i.LT.1 )
1234  $ a( j-i+1+kuu, i+n ) = czero
1235  IF( i.GE.1 .AND. i.NE.j ) THEN
1236  IF( isym.EQ.0 ) THEN
1237  a( j-i+1+kuu, i ) = conjg( a( i-j+kuu+1,
1238  $ j ) )
1239  ELSE
1240  a( j-i+1+kuu, i ) = a( i-j+kuu+1, j )
1241  END IF
1242  END IF
1243  520 CONTINUE
1244  530 CONTINUE
1245  ELSE IF( isym.EQ.1 ) THEN
1246  DO 550 j = 1, n
1247  DO 540 i = j - kuu, j + kll
1248  a( i-j+kuu+1, j ) = clatm2( m, n, i, j, kl, ku,
1249  $ idist, iseed, d, igrade, dl,
1250  $ dr, ipvtng, iwork, sparse )
1251  540 CONTINUE
1252  550 CONTINUE
1253  END IF
1254 *
1255  END IF
1256 *
1257  END IF
1258 *
1259 * 5) Scaling the norm
1260 *
1261  IF( ipack.EQ.0 ) THEN
1262  onorm = clange( 'M', m, n, a, lda, tempa )
1263  ELSE IF( ipack.EQ.1 ) THEN
1264  onorm = clansy( 'M', 'U', n, a, lda, tempa )
1265  ELSE IF( ipack.EQ.2 ) THEN
1266  onorm = clansy( 'M', 'L', n, a, lda, tempa )
1267  ELSE IF( ipack.EQ.3 ) THEN
1268  onorm = clansp( 'M', 'U', n, a, tempa )
1269  ELSE IF( ipack.EQ.4 ) THEN
1270  onorm = clansp( 'M', 'L', n, a, tempa )
1271  ELSE IF( ipack.EQ.5 ) THEN
1272  onorm = clansb( 'M', 'L', n, kll, a, lda, tempa )
1273  ELSE IF( ipack.EQ.6 ) THEN
1274  onorm = clansb( 'M', 'U', n, kuu, a, lda, tempa )
1275  ELSE IF( ipack.EQ.7 ) THEN
1276  onorm = clangb( 'M', n, kll, kuu, a, lda, tempa )
1277  END IF
1278 *
1279  IF( anorm.GE.zero ) THEN
1280 *
1281  IF( anorm.GT.zero .AND. onorm.EQ.zero ) THEN
1282 *
1283 * Desired scaling impossible
1284 *
1285  info = 5
1286  RETURN
1287 *
1288  ELSE IF( ( anorm.GT.one .AND. onorm.LT.one ) .OR.
1289  $ ( anorm.LT.one .AND. onorm.GT.one ) ) THEN
1290 *
1291 * Scale carefully to avoid over / underflow
1292 *
1293  IF( ipack.LE.2 ) THEN
1294  DO 560 j = 1, n
1295  CALL csscal( m, one / onorm, a( 1, j ), 1 )
1296  CALL csscal( m, anorm, a( 1, j ), 1 )
1297  560 CONTINUE
1298 *
1299  ELSE IF( ipack.EQ.3 .OR. ipack.EQ.4 ) THEN
1300 *
1301  CALL csscal( n*( n+1 ) / 2, one / onorm, a, 1 )
1302  CALL csscal( n*( n+1 ) / 2, anorm, a, 1 )
1303 *
1304  ELSE IF( ipack.GE.5 ) THEN
1305 *
1306  DO 570 j = 1, n
1307  CALL csscal( kll+kuu+1, one / onorm, a( 1, j ), 1 )
1308  CALL csscal( kll+kuu+1, anorm, a( 1, j ), 1 )
1309  570 CONTINUE
1310 *
1311  END IF
1312 *
1313  ELSE
1314 *
1315 * Scale straightforwardly
1316 *
1317  IF( ipack.LE.2 ) THEN
1318  DO 580 j = 1, n
1319  CALL csscal( m, anorm / onorm, a( 1, j ), 1 )
1320  580 CONTINUE
1321 *
1322  ELSE IF( ipack.EQ.3 .OR. ipack.EQ.4 ) THEN
1323 *
1324  CALL csscal( n*( n+1 ) / 2, anorm / onorm, a, 1 )
1325 *
1326  ELSE IF( ipack.GE.5 ) THEN
1327 *
1328  DO 590 j = 1, n
1329  CALL csscal( kll+kuu+1, anorm / onorm, a( 1, j ), 1 )
1330  590 CONTINUE
1331  END IF
1332 *
1333  END IF
1334 *
1335  END IF
1336 *
1337 * End of CLATMR
1338 *
subroutine xerbla(SRNAME, INFO)
XERBLA
Definition: xerbla.f:60
logical function lsame(CA, CB)
LSAME
Definition: lsame.f:53
subroutine csscal(N, SA, CX, INCX)
CSSCAL
Definition: csscal.f:78
complex function clatm2(M, N, I, J, KL, KU, IDIST, ISEED, D, IGRADE, DL, DR, IPVTNG, IWORK, SPARSE)
CLATM2
Definition: clatm2.f:212
complex function clatm3(M, N, I, J, ISUB, JSUB, KL, KU, IDIST, ISEED, D, IGRADE, DL, DR, IPVTNG, IWORK, SPARSE)
CLATM3
Definition: clatm3.f:229
subroutine clatm1(MODE, COND, IRSIGN, IDIST, ISEED, D, N, INFO)
CLATM1
Definition: clatm1.f:137
real function clangb(NORM, N, KL, KU, AB, LDAB, WORK)
CLANGB returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: clangb.f:125
real function clange(NORM, M, N, A, LDA, WORK)
CLANGE returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value ...
Definition: clange.f:115
real function clansb(NORM, UPLO, N, K, AB, LDAB, WORK)
CLANSB returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: clansb.f:130
real function clansp(NORM, UPLO, N, AP, WORK)
CLANSP returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: clansp.f:115
real function clansy(NORM, UPLO, N, A, LDA, WORK)
CLANSY returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,...
Definition: clansy.f:123
Here is the call graph for this function:
Here is the caller graph for this function: