--- name: "slatmt.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/slatmt.f" --- # slatmt.f(3) ## NAME TESTING/MATGEN/slatmt.f ## SYNOPSIS ### Functions/Subroutines subroutine **slatmt** (m, n, dist, iseed, sym, d, mode, cond, dmax, rank, kl, ku, pack, a, lda, work, info)\ **SLATMT** ## Function/Subroutine Documentation ### subroutine slatmt (integer m, integer n, character dist, integer, dimension( 4 ) iseed, character sym, real, dimension( \* ) d, integer mode, real cond, real dmax, integer rank, integer kl, integer ku, character pack, real, dimension( lda, \* ) a, integer lda, real, dimension( \* ) work, integer info) **SLATMT** **Purpose:** ``` !> !> SLATMT generates random matrices with specified singular values !> (or symmetric/hermitian with specified eigenvalues) !> for testing LAPACK programs. !> !> SLATMT operates by applying the following sequence of !> operations: !> !> Set the diagonal to D, where D may be input or !> computed according to MODE, COND, DMAX, and SYM !> as described below. !> !> Generate a matrix with the appropriate band structure, by one !> of two methods: !> !> Method A: !> Generate a dense M x N matrix by multiplying D on the left !> and the right by random unitary matrices, then: !> !> Reduce the bandwidth according to KL and KU, using !> Householder transformations. !> !> Method B: !> Convert the bandwidth-0 (i.e., diagonal) matrix to a !> bandwidth-1 matrix using Givens rotations, !> out-of-band elements back, much as in QR; then !> convert the bandwidth-1 to a bandwidth-2 matrix, etc. !> Note that for reasonably small bandwidths (relative to !> M and N) this requires less storage, as a dense matrix !> is not generated. Also, for symmetric matrices, only !> one triangle is generated. !> !> Method A is chosen if the bandwidth is a large fraction of the !> order of the matrix, and LDA is at least M (so a dense !> matrix can be stored.) Method B is chosen if the bandwidth !> is small (< 1/2 N for symmetric, < .3 N+M for !> non-symmetric), or LDA is less than M and not less than the !> bandwidth. !> !> Pack the matrix if desired. Options specified by PACK are: !> no packing !> zero out upper half (if symmetric) !> zero out lower half (if symmetric) !> store the upper half columnwise (if symmetric or upper !> triangular) !> store the lower half columnwise (if symmetric or lower !> triangular) !> store the lower triangle in banded format (if symmetric !> or lower triangular) !> store the upper triangle in banded format (if symmetric !> or upper triangular) !> store the entire matrix in banded format !> If Method B is chosen, and band format is specified, then the !> matrix will be generated in the band format, so no repacking !> will be necessary. !> ``` **Parameters** *M* ``` !> M is INTEGER !> The number of rows of A. Not modified. !> ``` *N* ``` !> N is INTEGER !> The number of columns of A. Not modified. !> ``` *DIST* ``` !> DIST is CHARACTER*1 !> On entry, DIST specifies the type of distribution to be used !> to generate the random eigen-/singular values. !> 'U' => UNIFORM( 0, 1 ) ( 'U' for uniform ) !> 'S' => UNIFORM( -1, 1 ) ( 'S' for symmetric ) !> 'N' => NORMAL( 0, 1 ) ( 'N' for normal ) !> Not modified. !> ``` *ISEED* ``` !> ISEED is INTEGER array, dimension ( 4 ) !> On entry ISEED specifies the seed of the random number !> generator. They should lie between 0 and 4095 inclusive, !> and ISEED(4) should be odd. The random number generator !> uses a linear congruential sequence limited to small !> integers, and so should produce machine independent !> random numbers. The values of ISEED are changed on !> exit, and can be used in the next call to SLATMT !> to continue the same random number sequence. !> Changed on exit. !> ``` *SYM* ``` !> SYM is CHARACTER*1 !> If SYM='S' or 'H', the generated matrix is symmetric, with !> eigenvalues specified by D, COND, MODE, and DMAX; they !> may be positive, negative, or zero. !> If SYM='P', the generated matrix is symmetric, with !> eigenvalues (= singular values) specified by D, COND, !> MODE, and DMAX; they will not be negative. !> If SYM='N', the generated matrix is nonsymmetric, with !> singular values specified by D, COND, MODE, and DMAX; !> they will not be negative. !> Not modified. !> ``` *D* ``` !> D is REAL array, dimension ( MIN( M , N ) ) !> This array is used to specify the singular values or !> eigenvalues of A (see SYM, above.) If MODE=0, then D is !> assumed to contain the singular/eigenvalues, otherwise !> they will be computed according to MODE, COND, and DMAX, !> and placed in D. !> Modified if MODE is nonzero. !> ``` *MODE* ``` !> MODE is INTEGER !> On entry this describes how the singular/eigenvalues are to !> be specified: !> MODE = 0 means use D as input !> !> MODE = 1 sets D(1)=1 and D(2:RANK)=1.0/COND !> MODE = 2 sets D(1:RANK-1)=1 and D(RANK)=1.0/COND !> MODE = 3 sets D(I)=COND**(-(I-1)/(RANK-1)) !> !> MODE = 4 sets D(i)=1 - (i-1)/(N-1)*(1 - 1/COND) !> MODE = 5 sets D to random numbers in the range !> ( 1/COND , 1 ) such that their logarithms !> are uniformly distributed. !> MODE = 6 set D to random numbers from same distribution !> as the rest of the matrix. !> MODE < 0 has the same meaning as ABS(MODE), except that !> the order of the elements of D is reversed. !> Thus if MODE is positive, D has entries ranging from !> 1 to 1/COND, if negative, from 1/COND to 1, !> If SYM='S' or 'H', and MODE is neither 0, 6, nor -6, then !> the elements of D will also be multiplied by a random !> sign (i.e., +1 or -1.) !> Not modified. !> ``` *COND* ``` !> COND is REAL !> On entry, this is used as described under MODE above. !> If used, it must be >= 1. Not modified. !> ``` *DMAX* ``` !> DMAX is REAL !> If MODE is neither -6, 0 nor 6, the contents of D, as !> computed according to MODE and COND, will be scaled by !> DMAX / max(abs(D(i))); thus, the maximum absolute eigen- or !> singular value (which is to say the norm) will be abs(DMAX). !> Note that DMAX need not be positive: if DMAX is negative !> (or zero), D will be scaled by a negative number (or zero). !> Not modified. !> ``` *RANK* ``` !> RANK is INTEGER !> The rank of matrix to be generated for modes 1,2,3 only. !> D( RANK+1:N ) = 0. !> Not modified. !> ``` *KL* ``` !> KL is INTEGER !> This specifies the lower bandwidth of the matrix. For !> example, KL=0 implies upper triangular, KL=1 implies upper !> Hessenberg, and KL being at least M-1 means that the matrix !> has full lower bandwidth. KL must equal KU if the matrix !> is symmetric. !> Not modified. !> ``` *KU* ``` !> KU is INTEGER !> This specifies the upper bandwidth of the matrix. For !> example, KU=0 implies lower triangular, KU=1 implies lower !> Hessenberg, and KU being at least N-1 means that the matrix !> has full upper bandwidth. KL must equal KU if the matrix !> is symmetric. !> Not modified. !> ``` *PACK* ``` !> PACK is CHARACTER*1 !> This specifies packing of matrix as follows: !> 'N' => no packing !> 'U' => zero out all subdiagonal entries (if symmetric) !> 'L' => zero out all superdiagonal entries (if symmetric) !> 'C' => store the upper triangle columnwise !> (only if the matrix is symmetric or upper triangular) !> 'R' => store the lower triangle columnwise !> (only if the matrix is symmetric or lower triangular) !> 'B' => store the lower triangle in band storage scheme !> (only if matrix symmetric or lower triangular) !> 'Q' => store the upper triangle in band storage scheme !> (only if matrix symmetric or upper triangular) !> 'Z' => store the entire matrix in band storage scheme !> (pivoting can be provided for by using this !> option to store A in the trailing rows of !> the allocated storage) !> !> Using these options, the various LAPACK packed and banded !> storage schemes can be obtained: !> GB - use 'Z' !> PB, SB or TB - use 'B' or 'Q' !> PP, SP or TP - use 'C' or 'R' !> !> If two calls to SLATMT differ only in the PACK parameter, !> they will generate mathematically equivalent matrices. !> Not modified. !> ``` *A* ``` !> A is REAL array, dimension ( LDA, N ) !> On exit A is the desired test matrix. A is first generated !> in full (unpacked) form, and then packed, if so specified !> by PACK. Thus, the first M elements of the first N !> columns will always be modified. If PACK specifies a !> packed or banded storage scheme, all LDA elements of the !> first N columns will be modified; the elements of the !> array which do not correspond to elements of the generated !> matrix are set to zero. !> Modified. !> ``` *LDA* ``` !> LDA is INTEGER !> LDA specifies the first dimension of A as declared in the !> calling program. If PACK='N', 'U', 'L', 'C', or 'R', then !> LDA must be at least M. If PACK='B' or 'Q', then LDA must !> be at least MIN( KL, M-1) (which is equal to MIN(KU,N-1)). !> If PACK='Z', LDA must be large enough to hold the packed !> array: MIN( KU, N-1) + MIN( KL, M-1) + 1. !> Not modified. !> ``` *WORK* ``` !> WORK is REAL array, dimension ( 3*MAX( N , M ) ) !> Workspace. !> Modified. !> ``` *INFO* ``` !> INFO is INTEGER !> Error code. On exit, INFO will be set to one of the !> following values: !> 0 => normal return !> -1 => M negative or unequal to N and SYM='S', 'H', or 'P' !> -2 => N negative !> -3 => DIST illegal string !> -5 => SYM illegal string !> -7 => MODE not in range -6 to 6 !> -8 => COND less than 1.0, and MODE neither -6, 0 nor 6 !> -10 => KL negative !> -11 => KU negative, or SYM='S' or 'H' and KU not equal to KL !> -12 => PACK illegal string, or PACK='U' or 'L', and SYM='N'; !> or PACK='C' or 'Q' and SYM='N' and KL is not zero; !> or PACK='R' or 'B' and SYM='N' and KU is not zero; !> or PACK='U', 'L', 'C', 'R', 'B', or 'Q', and M is not !> N. !> -14 => LDA is less than M, or PACK='Z' and LDA is less than !> MIN(KU,N-1) + MIN(KL,M-1) + 1. !> 1 => Error return from SLATM7 !> 2 => Cannot scale to DMAX (max. sing. value is 0) !> 3 => Error return from SLAGGE or SLAGSY !> ``` **Author** Univ. of Tennessee Univ. of California Berkeley Univ. of Colorado Denver NAG Ltd. Definition at line **329** of file **slatmt.f**. ## Author Generated automatically by Doxygen for LAPACK from the source code.