dlatm7()

subroutine dlatm7	(	integer	mode,
		double precision	cond,
		integer	irsign,
		integer	idist,
		integer, dimension( 4 )	iseed,
		double precision, dimension( * )	d,
		integer	n,
		integer	rank,
		integer	info )

DLATM7

Purpose:

!>
!>    DLATM7 computes the entries of D as specified by MODE
!>    COND and IRSIGN. IDIST and ISEED determine the generation
!>    of random numbers. DLATM7 is called by DLATMT to generate
!>    random test matrices.
!> 

!>  MODE   - INTEGER
!>           On entry describes how D is to be computed:
!>           MODE = 0 means do not change D.
!>
!>           MODE = 1 sets D(1)=1 and D(2:RANK)=1.0/COND
!>           MODE = 2 sets D(1:RANK-1)=1 and D(RANK)=1.0/COND
!>           MODE = 3 sets D(I)=COND**(-(I-1)/(RANK-1)) I=1:RANK
!>
!>           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.
!>
!>  COND   - DOUBLE PRECISION
!>           On entry, used as described under MODE above.
!>           If used, it must be >= 1. Not modified.
!>
!>  IRSIGN - INTEGER
!>           On entry, if MODE neither -6, 0 nor 6, determines sign of
!>           entries of D
!>           0 => leave entries of D unchanged
!>           1 => multiply each entry of D by 1 or -1 with probability .5
!>
!>  IDIST  - CHARACTER*1
!>           On entry, IDIST specifies the type of distribution to be
!>           used to generate a random matrix .
!>           1 => UNIFORM( 0, 1 )
!>           2 => UNIFORM( -1, 1 )
!>           3 => NORMAL( 0, 1 )
!>           Not modified.
!>
!>  ISEED  - INTEGER array, dimension ( 4 )
!>           On entry ISEED specifies the seed of the random number
!>           generator. 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 DLATM7
!>           to continue the same random number sequence.
!>           Changed on exit.
!>
!>  D      - DOUBLE PRECISION array, dimension ( MIN( M , N ) )
!>           Array to be computed according to MODE, COND and IRSIGN.
!>           May be changed on exit if MODE is nonzero.
!>
!>  N      - INTEGER
!>           Number of entries of D. Not modified.
!>
!>  RANK   - INTEGER
!>           The rank of matrix to be generated for modes 1,2,3 only.
!>           D( RANK+1:N ) = 0.
!>           Not modified.
!>
!>  INFO   - INTEGER
!>            0  => normal termination
!>           -1  => if MODE not in range -6 to 6
!>           -2  => if MODE neither -6, 0 nor 6, and
!>                  IRSIGN neither 0 nor 1
!>           -3  => if MODE neither -6, 0 nor 6 and COND less than 1
!>           -4  => if MODE equals 6 or -6 and IDIST not in range 1 to 3
!>           -7  => if N negative
!> 

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 120 of file dlatm7.f.

*
*  -- LAPACK computational routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
      DOUBLE PRECISION   COND
      INTEGER            IDIST, INFO, IRSIGN, MODE, N, RANK
*     ..
*     .. Array Arguments ..
      DOUBLE PRECISION   D( * )
      INTEGER            ISEED( 4 )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
      DOUBLE PRECISION   ONE
      parameter( one = 1.0d0 )
      DOUBLE PRECISION   ZERO
      parameter( zero = 0.0d0 )
      DOUBLE PRECISION   HALF
      parameter( half = 0.5d0 )
*     ..
*     .. Local Scalars ..
      DOUBLE PRECISION   ALPHA, TEMP
      INTEGER            I
*     ..
*     .. External Functions ..
      DOUBLE PRECISION   DLARAN
      EXTERNAL           dlaran
*     ..
*     .. External Subroutines ..
      EXTERNAL           dlarnv, xerbla
*     ..
*     .. Intrinsic Functions ..
      INTRINSIC          abs, dble, exp, log
*     ..
*     .. Executable Statements ..
*
*     Decode and Test the input parameters. Initialize flags & seed.
*
      info = 0
*
*     Quick return if possible
*
      IF( n.EQ.0 )
     $   RETURN
*
*     Set INFO if an error
*
      IF( mode.LT.-6 .OR. mode.GT.6 ) THEN
         info = -1
      ELSE IF( ( mode.NE.-6 .AND. mode.NE.0 .AND. mode.NE.6 ) .AND.
     $         ( irsign.NE.0 .AND. irsign.NE.1 ) ) THEN
         info = -2
      ELSE IF( ( mode.NE.-6 .AND. mode.NE.0 .AND. mode.NE.6 ) .AND.
     $         cond.LT.one ) THEN
         info = -3
      ELSE IF( ( mode.EQ.6 .OR. mode.EQ.-6 ) .AND.
     $         ( idist.LT.1 .OR. idist.GT.3 ) ) THEN
         info = -4
      ELSE IF( n.LT.0 ) THEN
         info = -7
      END IF
*
      IF( info.NE.0 ) THEN
         CALL xerbla( 'DLATM7', -info )
         RETURN
      END IF
*
*     Compute D according to COND and MODE
*
      IF( mode.NE.0 ) THEN
         GO TO ( 100, 130, 160, 190, 210, 230 )abs( mode )
*
*        One large D value:
*
  100    CONTINUE
         DO 110 i = 2, rank
            d( i ) = one / cond
  110    CONTINUE
         DO 120 i = rank + 1, n
            d( i ) = zero
  120    CONTINUE
         d( 1 ) = one
         GO TO 240
*
*        One small D value:
*
  130    CONTINUE
         DO 140 i = 1, rank - 1
            d( i ) = one
  140    CONTINUE
         DO 150 i = rank + 1, n
            d( i ) = zero
  150    CONTINUE
         d( rank ) = one / cond
         GO TO 240
*
*        Exponentially distributed D values:
*
  160    CONTINUE
         d( 1 ) = one
         IF( n.GT.1 .AND. rank.GT.1 ) THEN
            alpha = cond**( -one / dble( rank-1 ) )
            DO 170 i = 2, rank
               d( i ) = alpha**( i-1 )
  170       CONTINUE
            DO 180 i = rank + 1, n
               d( i ) = zero
  180       CONTINUE
         END IF
         GO TO 240
*
*        Arithmetically distributed D values:
*
  190    CONTINUE
         d( 1 ) = one
         IF( n.GT.1 ) THEN
            temp = one / cond
            alpha = ( one-temp ) / dble( n-1 )
            DO 200 i = 2, n
               d( i ) = dble( n-i )*alpha + temp
  200       CONTINUE
         END IF
         GO TO 240
*
*        Randomly distributed D values on ( 1/COND , 1):
*
  210    CONTINUE
         alpha = log( one / cond )
         DO 220 i = 1, n
            d( i ) = exp( alpha*dlaran( iseed ) )
  220    CONTINUE
         GO TO 240
*
*        Randomly distributed D values from IDIST
*
  230    CONTINUE
         CALL dlarnv( idist, iseed, n, d )
*
  240    CONTINUE
*
*        If MODE neither -6 nor 0 nor 6, and IRSIGN = 1, assign
*        random signs to D
*
         IF( ( mode.NE.-6 .AND. mode.NE.0 .AND. mode.NE.6 ) .AND.
     $       irsign.EQ.1 ) THEN
            DO 250 i = 1, n
               temp = dlaran( iseed )
               IF( temp.GT.half )
     $            d( i ) = -d( i )
  250       CONTINUE
         END IF
*
*        Reverse if MODE < 0
*
         IF( mode.LT.0 ) THEN
            DO 260 i = 1, n / 2
               temp = d( i )
               d( i ) = d( n+1-i )
               d( n+1-i ) = temp
  260       CONTINUE
         END IF
*
      END IF
*
      RETURN
*
*     End of DLATM7
*

Here is the call graph for this function:

Here is the caller graph for this function: