---
name: "slatm2.f"
section: "3"
platform: "linux"
package: "lapack-doc"
version: "3.12.1-2"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/slatm2.f"
---

# slatm2.f(3)

## NAME

TESTING/MATGEN/slatm2.f

## SYNOPSIS

### Functions/Subroutines

real function **slatm2** (m, n, i, j, kl, ku, idist, iseed, d, igrade, dl, dr, ipvtng, iwork, sparse)\
 **SLATM2**

## Function/Subroutine Documentation

### real function slatm2 (integer m, integer n, integer i, integer j, 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)

**SLATM2**

**Purpose:**

```
!>
!>    SLATM2 returns the (I,J) entry of a random matrix of dimension
!>    (M, N) described by the other parameters. It 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 SLATM2 differs from SLATM3 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
!>
!>    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**

*M*

```
!>          M is INTEGER
!>           Number of rows of matrix. Not modified.
!>
```

*N*

```
!>          N is INTEGER
!>           Number of columns of matrix. Not modified.
!>
```

*I*

```
!>          I is INTEGER
!>           Row of entry to be returned. Not modified.
!>
```

*J*

```
!>          J is INTEGER
!>           Column of entry to be returned. Not modified.
!>
```

*KL*

```
!>          KL is INTEGER
!>           Lower bandwidth. Not modified.
!>
```

*KU*

```
!>          KU is INTEGER
!>           Upper bandwidth. Not modified.
!>
```

*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.
!>
```

*ISEED*

```
!>          ISEED is INTEGER array of dimension ( 4 )
!>           Seed for random number generator.
!>           Changed on exit.
!>
```

*D*

```
!>          D is REAL array of dimension ( MIN( I , J ) )
!>           Diagonal entries of matrix. Not modified.
!>
```

*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.
!>
```

*DL*

```
!>          DL is REAL array ( I or J, as appropriate )
!>           Left scale factors for grading matrix.  Not modified.
!>
```

*DR*

```
!>          DR is REAL array ( I or J, as appropriate )
!>           Right scale factors for grading matrix.  Not modified.
!>
```

*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.
!>
```

*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 SLATM3. Not modified.
!>
```

*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 **206** of file **slatm2.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.