LAPACK  3.4.1
LAPACK: Linear Algebra PACKage
zlatm1.f
Go to the documentation of this file.
00001 *> \brief \b ZLATM1
00002 *
00003 *  =========== DOCUMENTATION ===========
00004 *
00005 * Online html documentation available at 
00006 *            http://www.netlib.org/lapack/explore-html/ 
00007 *
00008 *  Definition:
00009 *  ===========
00010 *
00011 *       SUBROUTINE ZLATM1( MODE, COND, IRSIGN, IDIST, ISEED, D, N, INFO )
00012 * 
00013 *       .. Scalar Arguments ..
00014 *       INTEGER            IDIST, INFO, IRSIGN, MODE, N
00015 *       DOUBLE PRECISION   COND
00016 *       ..
00017 *       .. Array Arguments ..
00018 *       INTEGER            ISEED( 4 )
00019 *       COMPLEX*16         D( * )
00020 *       ..
00021 *  
00022 *
00023 *> \par Purpose:
00024 *  =============
00025 *>
00026 *> \verbatim
00027 *>
00028 *>    ZLATM1 computes the entries of D(1..N) as specified by
00029 *>    MODE, COND and IRSIGN. IDIST and ISEED determine the generation
00030 *>    of random numbers. ZLATM1 is called by CLATMR to generate
00031 *>    random test matrices for LAPACK programs.
00032 *> \endverbatim
00033 *
00034 *  Arguments:
00035 *  ==========
00036 *
00037 *> \param[in] MODE
00038 *> \verbatim
00039 *>          MODE is INTEGER
00040 *>           On entry describes how D is to be computed:
00041 *>           MODE = 0 means do not change D.
00042 *>           MODE = 1 sets D(1)=1 and D(2:N)=1.0/COND
00043 *>           MODE = 2 sets D(1:N-1)=1 and D(N)=1.0/COND
00044 *>           MODE = 3 sets D(I)=COND**(-(I-1)/(N-1))
00045 *>           MODE = 4 sets D(i)=1 - (i-1)/(N-1)*(1 - 1/COND)
00046 *>           MODE = 5 sets D to random numbers in the range
00047 *>                    ( 1/COND , 1 ) such that their logarithms
00048 *>                    are uniformly distributed.
00049 *>           MODE = 6 set D to random numbers from same distribution
00050 *>                    as the rest of the matrix.
00051 *>           MODE < 0 has the same meaning as ABS(MODE), except that
00052 *>              the order of the elements of D is reversed.
00053 *>           Thus if MODE is positive, D has entries ranging from
00054 *>              1 to 1/COND, if negative, from 1/COND to 1,
00055 *>           Not modified.
00056 *> \endverbatim
00057 *>
00058 *> \param[in] COND
00059 *> \verbatim
00060 *>          COND is DOUBLE PRECISION
00061 *>           On entry, used as described under MODE above.
00062 *>           If used, it must be >= 1. Not modified.
00063 *> \endverbatim
00064 *>
00065 *> \param[in] IRSIGN
00066 *> \verbatim
00067 *>          IRSIGN is INTEGER
00068 *>           On entry, if MODE neither -6, 0 nor 6, determines sign of
00069 *>           entries of D
00070 *>           0 => leave entries of D unchanged
00071 *>           1 => multiply each entry of D by random complex number
00072 *>                uniformly distributed with absolute value 1
00073 *> \endverbatim
00074 *>
00075 *> \param[in] IDIST
00076 *> \verbatim
00077 *>          IDIST is CHARACTER*1
00078 *>           On entry, IDIST specifies the type of distribution to be
00079 *>           used to generate a random matrix .
00080 *>           1 => real and imaginary parts each UNIFORM( 0, 1 )
00081 *>           2 => real and imaginary parts each UNIFORM( -1, 1 )
00082 *>           3 => real and imaginary parts each NORMAL( 0, 1 )
00083 *>           4 => complex number uniform in DISK( 0, 1 )
00084 *>           Not modified.
00085 *> \endverbatim
00086 *>
00087 *> \param[in,out] ISEED
00088 *> \verbatim
00089 *>          ISEED is INTEGER array, dimension ( 4 )
00090 *>           On entry ISEED specifies the seed of the random number
00091 *>           generator. The random number generator uses a
00092 *>           linear congruential sequence limited to small
00093 *>           integers, and so should produce machine independent
00094 *>           random numbers. The values of ISEED are changed on
00095 *>           exit, and can be used in the next call to ZLATM1
00096 *>           to continue the same random number sequence.
00097 *>           Changed on exit.
00098 *> \endverbatim
00099 *>
00100 *> \param[in,out] D
00101 *> \verbatim
00102 *>          D is COMPLEX*16 array, dimension ( MIN( M , N ) )
00103 *>           Array to be computed according to MODE, COND and IRSIGN.
00104 *>           May be changed on exit if MODE is nonzero.
00105 *> \endverbatim
00106 *>
00107 *> \param[in] N
00108 *> \verbatim
00109 *>          N is INTEGER
00110 *>           Number of entries of D. Not modified.
00111 *> \endverbatim
00112 *>
00113 *> \param[out] INFO
00114 *> \verbatim
00115 *>          INFO is INTEGER
00116 *>            0  => normal termination
00117 *>           -1  => if MODE not in range -6 to 6
00118 *>           -2  => if MODE neither -6, 0 nor 6, and
00119 *>                  IRSIGN neither 0 nor 1
00120 *>           -3  => if MODE neither -6, 0 nor 6 and COND less than 1
00121 *>           -4  => if MODE equals 6 or -6 and IDIST not in range 1 to 4
00122 *>           -7  => if N negative
00123 *> \endverbatim
00124 *
00125 *  Authors:
00126 *  ========
00127 *
00128 *> \author Univ. of Tennessee 
00129 *> \author Univ. of California Berkeley 
00130 *> \author Univ. of Colorado Denver 
00131 *> \author NAG Ltd. 
00132 *
00133 *> \date November 2011
00134 *
00135 *> \ingroup complex16_matgen
00136 *
00137 *  =====================================================================
00138       SUBROUTINE ZLATM1( MODE, COND, IRSIGN, IDIST, ISEED, D, N, INFO )
00139 *
00140 *  -- LAPACK auxiliary routine (version 3.4.0) --
00141 *  -- LAPACK is a software package provided by Univ. of Tennessee,    --
00142 *  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
00143 *     November 2011
00144 *
00145 *     .. Scalar Arguments ..
00146       INTEGER            IDIST, INFO, IRSIGN, MODE, N
00147       DOUBLE PRECISION   COND
00148 *     ..
00149 *     .. Array Arguments ..
00150       INTEGER            ISEED( 4 )
00151       COMPLEX*16         D( * )
00152 *     ..
00153 *
00154 *  =====================================================================
00155 *
00156 *     .. Parameters ..
00157       DOUBLE PRECISION   ONE
00158       PARAMETER          ( ONE = 1.0D0 )
00159 *     ..
00160 *     .. Local Scalars ..
00161       INTEGER            I
00162       DOUBLE PRECISION   ALPHA, TEMP
00163       COMPLEX*16         CTEMP
00164 *     ..
00165 *     .. External Functions ..
00166       DOUBLE PRECISION   DLARAN
00167       COMPLEX*16         ZLARND
00168       EXTERNAL           DLARAN, ZLARND
00169 *     ..
00170 *     .. External Subroutines ..
00171       EXTERNAL           XERBLA, ZLARNV
00172 *     ..
00173 *     .. Intrinsic Functions ..
00174       INTRINSIC          ABS, DBLE, EXP, LOG
00175 *     ..
00176 *     .. Executable Statements ..
00177 *
00178 *     Decode and Test the input parameters. Initialize flags & seed.
00179 *
00180       INFO = 0
00181 *
00182 *     Quick return if possible
00183 *
00184       IF( N.EQ.0 )
00185      $   RETURN
00186 *
00187 *     Set INFO if an error
00188 *
00189       IF( MODE.LT.-6 .OR. MODE.GT.6 ) THEN
00190          INFO = -1
00191       ELSE IF( ( MODE.NE.-6 .AND. MODE.NE.0 .AND. MODE.NE.6 ) .AND.
00192      $         ( IRSIGN.NE.0 .AND. IRSIGN.NE.1 ) ) THEN
00193          INFO = -2
00194       ELSE IF( ( MODE.NE.-6 .AND. MODE.NE.0 .AND. MODE.NE.6 ) .AND.
00195      $         COND.LT.ONE ) THEN
00196          INFO = -3
00197       ELSE IF( ( MODE.EQ.6 .OR. MODE.EQ.-6 ) .AND.
00198      $         ( IDIST.LT.1 .OR. IDIST.GT.4 ) ) THEN
00199          INFO = -4
00200       ELSE IF( N.LT.0 ) THEN
00201          INFO = -7
00202       END IF
00203 *
00204       IF( INFO.NE.0 ) THEN
00205          CALL XERBLA( 'ZLATM1', -INFO )
00206          RETURN
00207       END IF
00208 *
00209 *     Compute D according to COND and MODE
00210 *
00211       IF( MODE.NE.0 ) THEN
00212          GO TO ( 10, 30, 50, 70, 90, 110 )ABS( MODE )
00213 *
00214 *        One large D value:
00215 *
00216    10    CONTINUE
00217          DO 20 I = 1, N
00218             D( I ) = ONE / COND
00219    20    CONTINUE
00220          D( 1 ) = ONE
00221          GO TO 120
00222 *
00223 *        One small D value:
00224 *
00225    30    CONTINUE
00226          DO 40 I = 1, N
00227             D( I ) = ONE
00228    40    CONTINUE
00229          D( N ) = ONE / COND
00230          GO TO 120
00231 *
00232 *        Exponentially distributed D values:
00233 *
00234    50    CONTINUE
00235          D( 1 ) = ONE
00236          IF( N.GT.1 ) THEN
00237             ALPHA = COND**( -ONE / DBLE( N-1 ) )
00238             DO 60 I = 2, N
00239                D( I ) = ALPHA**( I-1 )
00240    60       CONTINUE
00241          END IF
00242          GO TO 120
00243 *
00244 *        Arithmetically distributed D values:
00245 *
00246    70    CONTINUE
00247          D( 1 ) = ONE
00248          IF( N.GT.1 ) THEN
00249             TEMP = ONE / COND
00250             ALPHA = ( ONE-TEMP ) / DBLE( N-1 )
00251             DO 80 I = 2, N
00252                D( I ) = DBLE( N-I )*ALPHA + TEMP
00253    80       CONTINUE
00254          END IF
00255          GO TO 120
00256 *
00257 *        Randomly distributed D values on ( 1/COND , 1):
00258 *
00259    90    CONTINUE
00260          ALPHA = LOG( ONE / COND )
00261          DO 100 I = 1, N
00262             D( I ) = EXP( ALPHA*DLARAN( ISEED ) )
00263   100    CONTINUE
00264          GO TO 120
00265 *
00266 *        Randomly distributed D values from IDIST
00267 *
00268   110    CONTINUE
00269          CALL ZLARNV( IDIST, ISEED, N, D )
00270 *
00271   120    CONTINUE
00272 *
00273 *        If MODE neither -6 nor 0 nor 6, and IRSIGN = 1, assign
00274 *        random signs to D
00275 *
00276          IF( ( MODE.NE.-6 .AND. MODE.NE.0 .AND. MODE.NE.6 ) .AND.
00277      $       IRSIGN.EQ.1 ) THEN
00278             DO 130 I = 1, N
00279                CTEMP = ZLARND( 3, ISEED )
00280                D( I ) = D( I )*( CTEMP / ABS( CTEMP ) )
00281   130       CONTINUE
00282          END IF
00283 *
00284 *        Reverse if MODE < 0
00285 *
00286          IF( MODE.LT.0 ) THEN
00287             DO 140 I = 1, N / 2
00288                CTEMP = D( I )
00289                D( I ) = D( N+1-I )
00290                D( N+1-I ) = CTEMP
00291   140       CONTINUE
00292          END IF
00293 *
00294       END IF
00295 *
00296       RETURN
00297 *
00298 *     End of ZLATM1
00299 *
00300       END
 All Files Functions