slatm3()

real function slatm3	(	integer	m,
		integer	n,
		integer	i,
		integer	j,
		integer	isub,
		integer	jsub,
		integer	kl,
		integer	ku,
		integer	idist,
		integer, dimension( 4 )	iseed,
		real, dimension( * )	d,
		integer	igrade,
		real, dimension( * )	dl,
		real, dimension( * )	dr,
		integer	ipvtng,
		integer, dimension( * )	iwork,
		real	sparse )

SLATM3

Purpose:

!>
!>    SLATM3 returns the (ISUB,JSUB) entry of a random matrix of
!>    dimension (M, N) described by the other parameters. (ISUB,JSUB)
!>    is the final position of the (I,J) entry after pivoting
!>    according to IPVTNG and IWORK. SLATM3 is called by the
!>    SLATMR 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 SLATMR which has already checked the parameters.
!>
!>    Use of SLATM3 differs from SLATM2 in the order in which the random
!>    number generator is called to fill in random matrix entries.
!>    With SLATM2, the generator is called to fill in the pivoted matrix
!>    columnwise. With SLATM3, the generator is called to fill in the
!>    matrix columnwise, after which it is pivoted. Thus, SLATM3 can
!>    be used to construct random matrices which differ only in their
!>    order of rows and/or columns. SLATM2 is used to construct band
!>    matrices while avoiding calling the random number generator for
!>    entries outside the band (and therefore generating random numbers
!>    in different orders for different pivot orders).
!>
!>    The matrix whose (ISUB,JSUB) entry is returned is constructed as
!>    follows (this routine only computes one entry):
!>
!>      If ISUB is outside (1..M) or JSUB 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 unpivoted entry to be returned. Not modified. !>
[in]	J	!> J is INTEGER !> Column of unpivoted entry to be returned. Not modified. !>
[in,out]	ISUB	!> ISUB is INTEGER !> Row of pivoted entry to be returned. Changed on exit. !>
[in,out]	JSUB	!> JSUB is INTEGER !> Column of pivoted entry to be returned. Changed on exit. !>
[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 => UNIFORM( 0, 1 ) !> 2 => UNIFORM( -1, 1 ) !> 3 => NORMAL( 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 REAL 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( DL ) !> Not modified. !>
[in]	DL	!> DL is REAL array ( I or J, as appropriate ) !> Left scale factors for grading matrix. Not modified. !>
[in]	DR	!> DR is REAL 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. !>
[in]	IWORK	!> IWORK is INTEGER array ( I or J, as appropriate ) !> This array specifies the permutation used. The !> row (or column) originally in position K is in !> position IWORK( K ) after pivoting. !> This differs from IWORK for SLATM2. Not modified. !>
[in]	SPARSE	!> SPARSE is REAL 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 223 of file slatm3.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, ISUB, J, JSUB, KL,
     $                   KU, M, N
      REAL               SPARSE
*     ..
*
*     .. Array Arguments ..
*
      INTEGER            ISEED( 4 ), IWORK( * )
      REAL               D( * ), DL( * ), DR( * )
*     ..
*
*  =====================================================================
*
*     .. Parameters ..
*
      REAL               ZERO
      parameter( zero = 0.0e0 )
*     ..
*
*     .. Local Scalars ..
*
      REAL               TEMP
*     ..
*
*     .. External Functions ..
*
      REAL               SLARAN, SLARND
      EXTERNAL           slaran, slarnd
*     ..
*
*-----------------------------------------------------------------------
*
*     .. 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
         isub = i
         jsub = j
         slatm3 = zero
         RETURN
      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
*
*     Check for banding
*
      IF( jsub.GT.isub+ku .OR. jsub.LT.isub-kl ) THEN
         slatm3 = zero
         RETURN
      END IF
*
*     Check for sparsity
*
      IF( sparse.GT.zero ) THEN
         IF( slaran( iseed ).LT.sparse ) THEN
            slatm3 = zero
            RETURN
         END IF
      END IF
*
*     Compute entry and grade it according to IGRADE
*
      IF( i.EQ.j ) THEN
         temp = d( i )
      ELSE
         temp = slarnd( idist, iseed )
      END IF
      IF( igrade.EQ.1 ) THEN
         temp = temp*dl( i )
      ELSE IF( igrade.EQ.2 ) THEN
         temp = temp*dr( j )
      ELSE IF( igrade.EQ.3 ) THEN
         temp = temp*dl( i )*dr( j )
      ELSE IF( igrade.EQ.4 .AND. i.NE.j ) THEN
         temp = temp*dl( i ) / dl( j )
      ELSE IF( igrade.EQ.5 ) THEN
         temp = temp*dl( i )*dl( j )
      END IF
      slatm3 = temp
      RETURN
*
*     End of SLATM3
*

Here is the call graph for this function:

Here is the caller graph for this function: