zlatm2()

complex*16 function zlatm2	(	integer	m,
		integer	n,
		integer	i,
		integer	j,
		integer	kl,
		integer	ku,
		integer	idist,
		integer, dimension( 4 )	iseed,
		complex*16, dimension( * )	d,
		integer	igrade,
		complex*16, dimension( * )	dl,
		complex*16, dimension( * )	dr,
		integer	ipvtng,
		integer, dimension( * )	iwork,
		double precision	sparse )

ZLATM2

Purpose:

!>
!>    ZLATM2 returns the (I,J) entry of a random matrix of dimension
!>    (M, N) described by the other parameters. It is called by the
!>    ZLATMR routine in order to build random test matrices. No error
!>    checking on parameters is done, because this routine is called in
!>    a tight loop by ZLATMR which has already checked the parameters.
!>
!>    Use of ZLATM2 differs from CLATM3 in the order in which the random
!>    number generator is called to fill in random matrix entries.
!>    With ZLATM2, the generator is called to fill in the pivoted matrix
!>    columnwise. With ZLATM3, the generator is called to fill in the
!>    matrix columnwise, after which it is pivoted. Thus, ZLATM3 can
!>    be used to construct random matrices which differ only in their
!>    order of rows and/or columns. ZLATM2 is used to construct band
!>    matrices while avoiding calling the random number generator for
!>    entries outside the band (and therefore generating random numbers
!>
!>    The matrix whose (I,J) entry is returned is constructed as
!>    follows (this routine only computes one entry):
!>
!>      If I is outside (1..M) or J is outside (1..N), return zero
!>         (this is convenient for generating matrices in band format).
!>
!>      Generate a matrix A with random entries of distribution IDIST.
!>
!>      Set the diagonal to D.
!>
!>      Grade the matrix, if desired, from the left (by DL) and/or
!>         from the right (by DR or DL) as specified by IGRADE.
!>
!>      Permute, if desired, the rows and/or columns as specified by
!>         IPVTNG and IWORK.
!>
!>      Band the matrix to have lower bandwidth KL and upper
!>         bandwidth KU.
!>
!>      Set random entries to zero as specified by SPARSE.
!> 

Parameters

[in]	M	!> M is INTEGER !> Number of rows of matrix. Not modified. !>
[in]	N	!> N is INTEGER !> Number of columns of matrix. Not modified. !>
[in]	I	!> I is INTEGER !> Row of entry to be returned. Not modified. !>
[in]	J	!> J is INTEGER !> Column of entry to be returned. Not modified. !>
[in]	KL	!> KL is INTEGER !> Lower bandwidth. Not modified. !>
[in]	KU	!> KU is INTEGER !> Upper bandwidth. Not modified. !>
[in]	IDIST	!> IDIST is INTEGER !> On entry, IDIST specifies the type of distribution to be !> used to generate a random matrix . !> 1 => real and imaginary parts each UNIFORM( 0, 1 ) !> 2 => real and imaginary parts each UNIFORM( -1, 1 ) !> 3 => real and imaginary parts each NORMAL( 0, 1 ) !> 4 => complex number uniform in DISK( 0 , 1 ) !> Not modified. !>
[in,out]	ISEED	!> ISEED is INTEGER array of dimension ( 4 ) !> Seed for random number generator. !> Changed on exit. !>
[in]	D	!> D is COMPLEX*16 array of dimension ( MIN( I , J ) ) !> Diagonal entries of matrix. Not modified. !>
[in]	IGRADE	!> IGRADE is INTEGER !> Specifies grading of matrix as follows: !> 0 => no grading !> 1 => matrix premultiplied by diag( DL ) !> 2 => matrix postmultiplied by diag( DR ) !> 3 => matrix premultiplied by diag( DL ) and !> postmultiplied by diag( DR ) !> 4 => matrix premultiplied by diag( DL ) and !> postmultiplied by inv( diag( DL ) ) !> 5 => matrix premultiplied by diag( DL ) and !> postmultiplied by diag( CONJG(DL) ) !> 6 => matrix premultiplied by diag( DL ) and !> postmultiplied by diag( DL ) !> Not modified. !>
[in]	DL	!> DL is COMPLEX*16 array ( I or J, as appropriate ) !> Left scale factors for grading matrix. Not modified. !>
[in]	DR	!> DR is COMPLEX*16 array ( I or J, as appropriate ) !> Right scale factors for grading matrix. Not modified. !>
[in]	IPVTNG	!> IPVTNG is INTEGER !> On entry specifies pivoting permutations as follows: !> 0 => none. !> 1 => row pivoting. !> 2 => column pivoting. !> 3 => full pivoting, i.e., on both sides. !> Not modified. !>
[out]	IWORK	!> IWORK is INTEGER array ( I or J, as appropriate ) !> This array specifies the permutation used. The !> row (or column) in position K was originally in !> position IWORK( K ). !> This differs from IWORK for ZLATM3. Not modified. !>
[in]	SPARSE	!> SPARSE is DOUBLE PRECISION between 0. and 1. !> On entry specifies the sparsity of the matrix !> if sparse matrix is to be generated. !> SPARSE should lie between 0 and 1. !> 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. !>

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 209 of file zlatm2.f.

*
*  -- LAPACK auxiliary routine --
*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
*
*     .. Scalar Arguments ..
*
      INTEGER            I, IDIST, IGRADE, IPVTNG, J, KL, KU, M, N
      DOUBLE PRECISION   SPARSE
*     ..
*
*     .. Array Arguments ..
*
      INTEGER            ISEED( 4 ), IWORK( * )
      COMPLEX*16         D( * ), DL( * ), DR( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
*
      COMPLEX*16         CZERO
      parameter( czero = ( 0.0d0, 0.0d0 ) )
      DOUBLE PRECISION   ZERO
      parameter( zero = 0.0d0 )
*     ..
*
*     .. Local Scalars ..
*
      INTEGER            ISUB, JSUB
      COMPLEX*16         CTEMP
*     ..
*
*     .. External Functions ..
*
      DOUBLE PRECISION   DLARAN
      COMPLEX*16         ZLARND
      EXTERNAL           dlaran, zlarnd
*     ..
*
*     .. Intrinsic Functions ..
*
      INTRINSIC          dconjg
*     ..
*
*-----------------------------------------------------------------------
*
*     .. Executable Statements ..
*
*
*     Check for I and J in range
*
      IF( i.LT.1 .OR. i.GT.m .OR. j.LT.1 .OR. j.GT.n ) THEN
         zlatm2 = czero
         RETURN
      END IF
*
*     Check for banding
*
      IF( j.GT.i+ku .OR. j.LT.i-kl ) THEN
         zlatm2 = czero
         RETURN
      END IF
*
*     Check for sparsity
*
      IF( sparse.GT.zero ) THEN
         IF( dlaran( iseed ).LT.sparse ) THEN
            zlatm2 = czero
            RETURN
         END IF
      END IF
*
*     Compute subscripts depending on IPVTNG
*
      IF( ipvtng.EQ.0 ) THEN
         isub = i
         jsub = j
      ELSE IF( ipvtng.EQ.1 ) THEN
         isub = iwork( i )
         jsub = j
      ELSE IF( ipvtng.EQ.2 ) THEN
         isub = i
         jsub = iwork( j )
      ELSE IF( ipvtng.EQ.3 ) THEN
         isub = iwork( i )
         jsub = iwork( j )
      END IF
*
*     Compute entry and grade it according to IGRADE
*
      IF( isub.EQ.jsub ) THEN
         ctemp = d( isub )
      ELSE
         ctemp = zlarnd( idist, iseed )
      END IF
      IF( igrade.EQ.1 ) THEN
         ctemp = ctemp*dl( isub )
      ELSE IF( igrade.EQ.2 ) THEN
         ctemp = ctemp*dr( jsub )
      ELSE IF( igrade.EQ.3 ) THEN
         ctemp = ctemp*dl( isub )*dr( jsub )
      ELSE IF( igrade.EQ.4 .AND. isub.NE.jsub ) THEN
         ctemp = ctemp*dl( isub ) / dl( jsub )
      ELSE IF( igrade.EQ.5 ) THEN
         ctemp = ctemp*dl( isub )*dconjg( dl( jsub ) )
      ELSE IF( igrade.EQ.6 ) THEN
         ctemp = ctemp*dl( isub )*dl( jsub )
      END IF
      zlatm2 = ctemp
      RETURN
*
*     End of ZLATM2
*

Here is the call graph for this function:

Here is the caller graph for this function: