LAPACK 3.3.1 Linear Algebra PACKage

# clatm3.f

Go to the documentation of this file.
```00001       COMPLEX FUNCTION CLATM3( M, N, I, J, ISUB, JSUB, KL, KU, IDIST,
00002      \$                         ISEED, D, IGRADE, DL, DR, IPVTNG, IWORK,
00003      \$                         SPARSE )
00004 *
00005 *  -- LAPACK auxiliary test routine (version 3.1) --
00006 *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
00007 *     June 2010
00008 *
00009 *     .. Scalar Arguments ..
00010 *
00011       INTEGER            I, IDIST, IGRADE, IPVTNG, ISUB, J, JSUB, KL,
00012      \$                   KU, M, N
00013       REAL               SPARSE
00014 *     ..
00015 *
00016 *     .. Array Arguments ..
00017 *
00018       INTEGER            ISEED( 4 ), IWORK( * )
00019       COMPLEX            D( * ), DL( * ), DR( * )
00020 *     ..
00021 *
00022 *  Purpose
00023 *  =======
00024 *
00025 *     CLATM3 returns the (ISUB,JSUB) entry of a random matrix of
00026 *     dimension (M, N) described by the other paramters. (ISUB,JSUB)
00027 *     is the final position of the (I,J) entry after pivoting
00028 *     according to IPVTNG and IWORK. CLATM3 is called by the
00029 *     CLATMR routine in order to build random test matrices. No error
00030 *     checking on parameters is done, because this routine is called in
00031 *     a tight loop by CLATMR which has already checked the parameters.
00032 *
00033 *     Use of CLATM3 differs from CLATM2 in the order in which the random
00034 *     number generator is called to fill in random matrix entries.
00035 *     With CLATM2, the generator is called to fill in the pivoted matrix
00036 *     columnwise. With CLATM3, the generator is called to fill in the
00037 *     matrix columnwise, after which it is pivoted. Thus, CLATM3 can
00038 *     be used to construct random matrices which differ only in their
00039 *     order of rows and/or columns. CLATM2 is used to construct band
00040 *     matrices while avoiding calling the random number generator for
00041 *     entries outside the band (and therefore generating random numbers
00042 *     in different orders for different pivot orders).
00043 *
00044 *     The matrix whose (ISUB,JSUB) entry is returned is constructed as
00045 *     follows (this routine only computes one entry):
00046 *
00047 *       If ISUB is outside (1..M) or JSUB is outside (1..N), return zero
00048 *          (this is convenient for generating matrices in band format).
00049 *
00050 *       Generate a matrix A with random entries of distribution IDIST.
00051 *
00052 *       Set the diagonal to D.
00053 *
00054 *       Grade the matrix, if desired, from the left (by DL) and/or
00055 *          from the right (by DR or DL) as specified by IGRADE.
00056 *
00057 *       Permute, if desired, the rows and/or columns as specified by
00058 *          IPVTNG and IWORK.
00059 *
00060 *       Band the matrix to have lower bandwidth KL and upper
00061 *          bandwidth KU.
00062 *
00063 *       Set random entries to zero as specified by SPARSE.
00064 *
00065 *  Arguments
00066 *  =========
00067 *
00068 *  M        (input) INTEGER
00069 *           Number of rows of matrix. Not modified.
00070 *
00071 *  N        (input) INTEGER
00072 *           Number of columns of matrix. Not modified.
00073 *
00074 *  I        (input) INTEGER
00075 *           Row of unpivoted entry to be returned. Not modified.
00076 *
00077 *  J        (input) INTEGER
00078 *           Column of unpivoted entry to be returned. Not modified.
00079 *
00080 *  ISUB    (input/output) INTEGER
00081 *           Row of pivoted entry to be returned. Changed on exit.
00082 *
00083 *  JSUB     (input/output) INTEGER
00084 *           Column of pivoted entry to be returned. Changed on exit.
00085 *
00086 *  KL       (input) INTEGER
00087 *           Lower bandwidth. Not modified.
00088 *
00089 *  KU       (input) INTEGER
00090 *           Upper bandwidth. Not modified.
00091 *
00092 *  IDIST    (input) INTEGER
00093 *           On entry, IDIST specifies the type of distribution to be
00094 *           used to generate a random matrix .
00095 *           1 => real and imaginary parts each UNIFORM( 0, 1 )
00096 *           2 => real and imaginary parts each UNIFORM( -1, 1 )
00097 *           3 => real and imaginary parts each NORMAL( 0, 1 )
00098 *           4 => complex number uniform in DISK( 0 , 1 )
00099 *           Not modified.
00100 *
00101 *  ISEED    (input/output) INTEGER array of dimension ( 4 )
00102 *           Seed for random number generator.
00103 *           Changed on exit.
00104 *
00105 *  D        (input) COMPLEX array of dimension ( MIN( I , J ) )
00106 *           Diagonal entries of matrix. Not modified.
00107 *
00109 *           Specifies grading of matrix as follows:
00110 *           0  => no grading
00111 *           1  => matrix premultiplied by diag( DL )
00112 *           2  => matrix postmultiplied by diag( DR )
00113 *           3  => matrix premultiplied by diag( DL ) and
00114 *                         postmultiplied by diag( DR )
00115 *           4  => matrix premultiplied by diag( DL ) and
00116 *                         postmultiplied by inv( diag( DL ) )
00117 *           5  => matrix premultiplied by diag( DL ) and
00118 *                         postmultiplied by diag( CONJG(DL) )
00119 *           6  => matrix premultiplied by diag( DL ) and
00120 *                         postmultiplied by diag( DL )
00121 *           Not modified.
00122 *
00123 *  DL       (input) COMPLEX array ( I or J, as appropriate )
00124 *           Left scale factors for grading matrix.  Not modified.
00125 *
00126 *  DR       (input) COMPLEX array ( I or J, as appropriate )
00127 *           Right scale factors for grading matrix.  Not modified.
00128 *
00129 *  IPVTNG   (input) INTEGER
00130 *           On entry specifies pivoting permutations as follows:
00131 *           0 => none.
00132 *           1 => row pivoting.
00133 *           2 => column pivoting.
00134 *           3 => full pivoting, i.e., on both sides.
00135 *           Not modified.
00136 *
00137 *  IWORK    (input) INTEGER array ( I or J, as appropriate )
00138 *           This array specifies the permutation used. The
00139 *           row (or column) originally in position K is in
00140 *           position IWORK( K ) after pivoting.
00141 *           This differs from IWORK for CLATM2. Not modified.
00142 *
00143 *  SPARSE   (input) REAL between 0. and 1.
00144 *           On entry specifies the sparsity of the matrix
00145 *           if sparse matix is to be generated.
00146 *           SPARSE should lie between 0 and 1.
00147 *           A uniform ( 0, 1 ) random number x is generated and
00148 *           compared to SPARSE; if x is larger the matrix entry
00149 *           is unchanged and if x is smaller the entry is set
00150 *           to zero. Thus on the average a fraction SPARSE of the
00151 *           entries will be set to zero.
00152 *           Not modified.
00153 *
00154 *  =====================================================================
00155 *
00156 *     .. Parameters ..
00157 *
00158       REAL               ZERO
00159       PARAMETER          ( ZERO = 0.0E0 )
00160       COMPLEX            CZERO
00161       PARAMETER          ( CZERO = ( 0.0E0, 0.0E0 ) )
00162 *     ..
00163 *
00164 *     .. Local Scalars ..
00165 *
00166       COMPLEX            CTEMP
00167 *     ..
00168 *
00169 *     .. External Functions ..
00170 *
00171       REAL               SLARAN
00172       COMPLEX            CLARND
00173       EXTERNAL           SLARAN, CLARND
00174 *     ..
00175 *
00176 *     .. Intrinsic Functions ..
00177 *
00178       INTRINSIC          CONJG
00179 *     ..
00180 *
00181 *-----------------------------------------------------------------------
00182 *
00183 *     .. Executable Statements ..
00184 *
00185 *
00186 *     Check for I and J in range
00187 *
00188       IF( I.LT.1 .OR. I.GT.M .OR. J.LT.1 .OR. J.GT.N ) THEN
00189          ISUB = I
00190          JSUB = J
00191          CLATM3 = CZERO
00192          RETURN
00193       END IF
00194 *
00195 *     Compute subscripts depending on IPVTNG
00196 *
00197       IF( IPVTNG.EQ.0 ) THEN
00198          ISUB = I
00199          JSUB = J
00200       ELSE IF( IPVTNG.EQ.1 ) THEN
00201          ISUB = IWORK( I )
00202          JSUB = J
00203       ELSE IF( IPVTNG.EQ.2 ) THEN
00204          ISUB = I
00205          JSUB = IWORK( J )
00206       ELSE IF( IPVTNG.EQ.3 ) THEN
00207          ISUB = IWORK( I )
00208          JSUB = IWORK( J )
00209       END IF
00210 *
00211 *     Check for banding
00212 *
00213       IF( JSUB.GT.ISUB+KU .OR. JSUB.LT.ISUB-KL ) THEN
00214          CLATM3 = CZERO
00215          RETURN
00216       END IF
00217 *
00218 *     Check for sparsity
00219 *
00220       IF( SPARSE.GT.ZERO ) THEN
00221          IF( SLARAN( ISEED ).LT.SPARSE ) THEN
00222             CLATM3 = CZERO
00223             RETURN
00224          END IF
00225       END IF
00226 *
00228 *
00229       IF( I.EQ.J ) THEN
00230          CTEMP = D( I )
00231       ELSE
00232          CTEMP = CLARND( IDIST, ISEED )
00233       END IF
00235          CTEMP = CTEMP*DL( I )
00236       ELSE IF( IGRADE.EQ.2 ) THEN
00237          CTEMP = CTEMP*DR( J )
00238       ELSE IF( IGRADE.EQ.3 ) THEN
00239          CTEMP = CTEMP*DL( I )*DR( J )
00240       ELSE IF( IGRADE.EQ.4 .AND. I.NE.J ) THEN
00241          CTEMP = CTEMP*DL( I ) / DL( J )
00242       ELSE IF( IGRADE.EQ.5 ) THEN
00243          CTEMP = CTEMP*DL( I )*CONJG( DL( J ) )
00244       ELSE IF( IGRADE.EQ.6 ) THEN
00245          CTEMP = CTEMP*DL( I )*DL( J )
00246       END IF
00247       CLATM3 = CTEMP
00248       RETURN
00249 *
00250 *     End of CLATM3
00251 *
00252       END
```