## table of contents

realOTHERauxiliary(3) | LAPACK | realOTHERauxiliary(3) |

# NAME¶

realOTHERauxiliary

# SYNOPSIS¶

## Functions¶

integer function **ilaslc** (M, N, A, LDA)

**ILASLC** scans a matrix for its last non-zero column. integer function
**ilaslr** (M, N, A, LDA)

**ILASLR** scans a matrix for its last non-zero row. subroutine
**slabrd** (M, N, NB, A, LDA, D, E, TAUQ, TAUP, X, LDX, Y, LDY)

**SLABRD** reduces the first nb rows and columns of a general matrix to a
bidiagonal form. subroutine **slacn2** (N, V, X, ISGN, EST, KASE, ISAVE)

**SLACN2** estimates the 1-norm of a square matrix, using reverse
communication for evaluating matrix-vector products. subroutine
**slacon** (N, V, X, ISGN, EST, KASE)

**SLACON** estimates the 1-norm of a square matrix, using reverse
communication for evaluating matrix-vector products. subroutine
**sladiv** (A, B, C, D, P, Q)

**SLADIV** performs complex division in real arithmetic, avoiding
unnecessary overflow. subroutine **sladiv1** (A, B, C, D, P, Q)

real function **sladiv2** (A, B, C, D, R, T)

subroutine **slaein** (RIGHTV, NOINIT, N, H, LDH, WR, WI, VR, VI, B, LDB,
WORK, EPS3, SMLNUM, BIGNUM, INFO)

**SLAEIN** computes a specified right or left eigenvector of an upper
Hessenberg matrix by inverse iteration. subroutine **slaexc** (WANTQ, N,
T, LDT, Q, LDQ, J1, N1, N2, WORK, INFO)

**SLAEXC** swaps adjacent diagonal blocks of a real upper quasi-triangular
matrix in Schur canonical form, by an orthogonal similarity transformation.
subroutine **slag2** (A, LDA, B, LDB, SAFMIN, SCALE1, SCALE2, WR1, WR2,
WI)

**SLAG2** computes the eigenvalues of a 2-by-2 generalized eigenvalue
problem, with scaling as necessary to avoid over-/underflow. subroutine
**slags2** (UPPER, A1, A2, A3, B1, B2, B3, CSU, SNU, CSV, SNV, CSQ, SNQ)

**SLAGS2** computes 2-by-2 orthogonal matrices U, V, and Q, and applies
them to matrices A and B such that the rows of the transformed A and B are
parallel. subroutine **slagtm** (TRANS, N, NRHS, ALPHA, DL, D, DU, X,
LDX, BETA, B, LDB)

**SLAGTM** performs a matrix-matrix product of the form C =
αAB+βC, where A is a tridiagonal matrix, B and C are
rectangular matrices, and α and β are scalars, which may be 0,
1, or -1. subroutine **slagv2** (A, LDA, B, LDB, ALPHAR, ALPHAI, BETA,
CSL, SNL, CSR, SNR)

**SLAGV2** computes the Generalized Schur factorization of a real 2-by-2
matrix pencil (A,B) where B is upper triangular. subroutine **slahqr**
(WANTT, WANTZ, N, ILO, IHI, H, LDH, WR, WI, ILOZ, IHIZ, Z, LDZ, INFO)

**SLAHQR** computes the eigenvalues and Schur factorization of an upper
Hessenberg matrix, using the double-shift/single-shift QR algorithm.
subroutine **slahr2** (N, K, NB, A, LDA, TAU, T, LDT, Y, LDY)

**SLAHR2** reduces the specified number of first columns of a general
rectangular matrix A so that elements below the specified subdiagonal are
zero, and returns auxiliary matrices which are needed to apply the
transformation to the unreduced part of A. subroutine **slaic1** (JOB, J,
X, SEST, W, GAMMA, SESTPR, S, C)

**SLAIC1** applies one step of incremental condition estimation. subroutine
**slaln2** (LTRANS, NA, NW, SMIN, CA, A, LDA, D1, D2, B, LDB, WR, WI, X,
LDX, SCALE, XNORM, INFO)

**SLALN2** solves a 1-by-1 or 2-by-2 linear system of equations of the
specified form. real function **slangt** (NORM, N, DL, D, DU)

**SLANGT** returns the value of the 1-norm, Frobenius norm, infinity-norm,
or the largest absolute value of any element of a general tridiagonal
matrix. real function **slanhs** (NORM, N, A, LDA, WORK)

**SLANHS** returns the value of the 1-norm, Frobenius norm, infinity-norm,
or the largest absolute value of any element of an upper Hessenberg matrix.
real function **slansb** (NORM, UPLO, N, K, AB, LDAB, WORK)

**SLANSB** returns the value of the 1-norm, or the Frobenius norm, or the
infinity norm, or the element of largest absolute value of a symmetric band
matrix. real function **slansp** (NORM, UPLO, N, AP, WORK)

**SLANSP** returns the value of the 1-norm, or the Frobenius norm, or the
infinity norm, or the element of largest absolute value of a symmetric
matrix supplied in packed form. real function **slantb** (NORM, UPLO,
DIAG, N, K, AB, LDAB, WORK)

**SLANTB** returns the value of the 1-norm, or the Frobenius norm, or the
infinity norm, or the element of largest absolute value of a triangular band
matrix. real function **slantp** (NORM, UPLO, DIAG, N, AP, WORK)

**SLANTP** returns the value of the 1-norm, or the Frobenius norm, or the
infinity norm, or the element of largest absolute value of a triangular
matrix supplied in packed form. real function **slantr** (NORM, UPLO,
DIAG, M, N, A, LDA, WORK)

**SLANTR** returns the value of the 1-norm, or the Frobenius norm, or the
infinity norm, or the element of largest absolute value of a trapezoidal or
triangular matrix. subroutine **slanv2** (A, B, C, D, RT1R, RT1I, RT2R,
RT2I, CS, SN)

**SLANV2** computes the Schur factorization of a real 2-by-2 nonsymmetric
matrix in standard form. subroutine **slapll** (N, X, INCX, Y, INCY,
SSMIN)

**SLAPLL** measures the linear dependence of two vectors. subroutine
**slapmr** (FORWRD, M, N, X, LDX, K)

**SLAPMR** rearranges rows of a matrix as specified by a permutation
vector. subroutine **slapmt** (FORWRD, M, N, X, LDX, K)

**SLAPMT** performs a forward or backward permutation of the columns of a
matrix. subroutine **slaqp2** (M, N, OFFSET, A, LDA, JPVT, TAU, VN1, VN2,
WORK)

**SLAQP2** computes a QR factorization with column pivoting of the matrix
block. subroutine **slaqps** (M, N, OFFSET, NB, KB, A, LDA, JPVT, TAU,
VN1, VN2, AUXV, F, LDF)

**SLAQPS** computes a step of QR factorization with column pivoting of a
real m-by-n matrix A by using BLAS level 3. subroutine **slaqr0** (WANTT,
WANTZ, N, ILO, IHI, H, LDH, WR, WI, ILOZ, IHIZ, Z, LDZ, WORK, LWORK, INFO)

**SLAQR0** computes the eigenvalues of a Hessenberg matrix, and optionally
the matrices from the Schur decomposition. subroutine **slaqr1** (N, H,
LDH, SR1, SI1, SR2, SI2, V)

**SLAQR1** sets a scalar multiple of the first column of the product of
2-by-2 or 3-by-3 matrix H and specified shifts. subroutine **slaqr2**
(WANTT, WANTZ, N, KTOP, KBOT, NW, H, LDH, ILOZ, IHIZ, Z, LDZ, NS, ND, SR,
SI, V, LDV, NH, T, LDT, NV, WV, LDWV, WORK, LWORK)

**SLAQR2** performs the orthogonal similarity transformation of a
Hessenberg matrix to detect and deflate fully converged eigenvalues from a
trailing principal submatrix (aggressive early deflation). subroutine
**slaqr3** (WANTT, WANTZ, N, KTOP, KBOT, NW, H, LDH, ILOZ, IHIZ, Z, LDZ,
NS, ND, SR, SI, V, LDV, NH, T, LDT, NV, WV, LDWV, WORK, LWORK)

**SLAQR3** performs the orthogonal similarity transformation of a
Hessenberg matrix to detect and deflate fully converged eigenvalues from a
trailing principal submatrix (aggressive early deflation). subroutine
**slaqr4** (WANTT, WANTZ, N, ILO, IHI, H, LDH, WR, WI, ILOZ, IHIZ, Z,
LDZ, WORK, LWORK, INFO)

**SLAQR4** computes the eigenvalues of a Hessenberg matrix, and optionally
the matrices from the Schur decomposition. subroutine **slaqr5** (WANTT,
WANTZ, KACC22, N, KTOP, KBOT, NSHFTS, SR, SI, H, LDH, ILOZ, IHIZ, Z, LDZ, V,
LDV, U, LDU, NV, WV, LDWV, NH, WH, LDWH)

**SLAQR5** performs a single small-bulge multi-shift QR sweep. subroutine
**slaqsb** (UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, EQUED)

**SLAQSB** scales a symmetric/Hermitian band matrix, using scaling factors
computed by spbequ. subroutine **slaqsp** (UPLO, N, AP, S, SCOND, AMAX,
EQUED)

**SLAQSP** scales a symmetric/Hermitian matrix in packed storage, using
scaling factors computed by sppequ. subroutine **slaqtr** (LTRAN, LREAL,
N, T, LDT, B, W, SCALE, X, WORK, INFO)

**SLAQTR** solves a real quasi-triangular system of equations, or a complex
quasi-triangular system of special form, in real arithmetic. subroutine
**slar1v** (N, B1, BN, LAMBDA, D, L, LD, LLD, PIVMIN, GAPTOL, Z, WANTNC,
NEGCNT, ZTZ, MINGMA, R, ISUPPZ, NRMINV, RESID, RQCORR, WORK)

**SLAR1V** computes the (scaled) r-th column of the inverse of the
submatrix in rows b1 through bn of the tridiagonal matrix LDLT - λI.
subroutine **slar2v** (N, X, Y, Z, INCX, C, S, INCC)

**SLAR2V** applies a vector of plane rotations with real cosines and real
sines from both sides to a sequence of 2-by-2 symmetric/Hermitian matrices.
subroutine **slarf** (SIDE, M, N, V, INCV, TAU, C, LDC, WORK)

**SLARF** applies an elementary reflector to a general rectangular matrix.
subroutine **slarfb** (SIDE, TRANS, DIRECT, STOREV, M, N, K, V, LDV, T,
LDT, C, LDC, WORK, LDWORK)

**SLARFB** applies a block reflector or its transpose to a general
rectangular matrix. subroutine **slarfg** (N, ALPHA, X, INCX, TAU)

**SLARFG** generates an elementary reflector (Householder matrix).
subroutine **slarfgp** (N, ALPHA, X, INCX, TAU)

**SLARFGP** generates an elementary reflector (Householder matrix) with
non-negative beta. subroutine **slarft** (DIRECT, STOREV, N, K, V, LDV,
TAU, T, LDT)

**SLARFT** forms the triangular factor T of a block reflector H = I - vtvH
subroutine **slarfx** (SIDE, M, N, V, TAU, C, LDC, WORK)

**SLARFX** applies an elementary reflector to a general rectangular matrix,
with loop unrolling when the reflector has order ≤ 10. subroutine
**slarfy** (UPLO, N, V, INCV, TAU, C, LDC, WORK)

**SLARFY** subroutine **slargv** (N, X, INCX, Y, INCY, C, INCC)

**SLARGV** generates a vector of plane rotations with real cosines and real
sines. subroutine **slarrv** (N, VL, VU, D, L, PIVMIN, ISPLIT, M, DOL,
DOU, MINRGP, RTOL1, RTOL2, W, WERR, WGAP, IBLOCK, INDEXW, GERS, Z, LDZ,
ISUPPZ, WORK, IWORK, INFO)

**SLARRV** computes the eigenvectors of the tridiagonal matrix T = L D LT
given L, D and the eigenvalues of L D LT. subroutine **slartv** (N, X,
INCX, Y, INCY, C, S, INCC)

**SLARTV** applies a vector of plane rotations with real cosines and real
sines to the elements of a pair of vectors. subroutine **slaswp** (N, A,
LDA, K1, K2, IPIV, INCX)

**SLASWP** performs a series of row interchanges on a general rectangular
matrix. subroutine **slatbs** (UPLO, TRANS, DIAG, NORMIN, N, KD, AB,
LDAB, X, SCALE, CNORM, INFO)

**SLATBS** solves a triangular banded system of equations. subroutine
**slatdf** (IJOB, N, Z, LDZ, RHS, RDSUM, RDSCAL, IPIV, JPIV)

**SLATDF** uses the LU factorization of the n-by-n matrix computed by
sgetc2 and computes a contribution to the reciprocal Dif-estimate.
subroutine **slatps** (UPLO, TRANS, DIAG, NORMIN, N, AP, X, SCALE, CNORM,
INFO)

**SLATPS** solves a triangular system of equations with the matrix held in
packed storage. subroutine **slatrs** (UPLO, TRANS, DIAG, NORMIN, N, A,
LDA, X, SCALE, CNORM, INFO)

**SLATRS** solves a triangular system of equations with the scale factor
set to prevent overflow. subroutine **slauu2** (UPLO, N, A, LDA, INFO)

**SLAUU2** computes the product UUH or LHL, where U and L are upper or
lower triangular matrices (unblocked algorithm). subroutine **slauum**
(UPLO, N, A, LDA, INFO)

**SLAUUM** computes the product UUH or LHL, where U and L are upper or
lower triangular matrices (blocked algorithm). subroutine **srscl** (N,
SA, SX, INCX)

**SRSCL** multiplies a vector by the reciprocal of a real scalar.
subroutine **stprfb** (SIDE, TRANS, DIRECT, STOREV, M, N, K, L, V, LDV,
T, LDT, A, LDA, B, LDB, WORK, LDWORK)

**STPRFB** applies a real or complex 'triangular-pentagonal' blocked
reflector to a real or complex matrix, which is composed of two blocks.

# Detailed Description¶

This is the group of real other auxiliary routines

# Function Documentation¶

## integer function ilaslc (integer M, integer N, real, dimension( lda, * ) A, integer LDA)¶

**ILASLC** scans a matrix for its last non-zero column.

**Purpose:**

ILASLC scans A for its last non-zero column.

**Parameters**

*M*

M is INTEGER

The number of rows of the matrix A.

*N*

N is INTEGER

The number of columns of the matrix A.

*A*

A is REAL array, dimension (LDA,N)

The m by n matrix A.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,M).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## integer function ilaslr (integer M, integer N, real, dimension( lda, * ) A, integer LDA)¶

**ILASLR** scans a matrix for its last non-zero row.

**Purpose:**

ILASLR scans A for its last non-zero row.

**Parameters**

*M*

M is INTEGER

The number of rows of the matrix A.

*N*

N is INTEGER

The number of columns of the matrix A.

*A*

A is REAL array, dimension (LDA,N)

The m by n matrix A.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,M).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slabrd (integer M, integer N, integer NB, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) D, real, dimension( * ) E, real, dimension( * ) TAUQ, real, dimension( * ) TAUP, real, dimension( ldx, * ) X, integer LDX, real, dimension( ldy, * ) Y, integer LDY)¶

**SLABRD** reduces the first nb rows and columns of a general
matrix to a bidiagonal form.

**Purpose:**

SLABRD reduces the first NB rows and columns of a real general

m by n matrix A to upper or lower bidiagonal form by an orthogonal

transformation Q**T * A * P, and returns the matrices X and Y which

are needed to apply the transformation to the unreduced part of A.

If m >= n, A is reduced to upper bidiagonal form; if m < n, to lower

bidiagonal form.

This is an auxiliary routine called by SGEBRD

**Parameters**

*M*

M is INTEGER

The number of rows in the matrix A.

*N*

N is INTEGER

The number of columns in the matrix A.

*NB*

NB is INTEGER

The number of leading rows and columns of A to be reduced.

*A*

A is REAL array, dimension (LDA,N)

On entry, the m by n general matrix to be reduced.

On exit, the first NB rows and columns of the matrix are

overwritten; the rest of the array is unchanged.

If m >= n, elements on and below the diagonal in the first NB

columns, with the array TAUQ, represent the orthogonal

matrix Q as a product of elementary reflectors; and

elements above the diagonal in the first NB rows, with the

array TAUP, represent the orthogonal matrix P as a product

of elementary reflectors.

If m < n, elements below the diagonal in the first NB

columns, with the array TAUQ, represent the orthogonal

matrix Q as a product of elementary reflectors, and

elements on and above the diagonal in the first NB rows,

with the array TAUP, represent the orthogonal matrix P as

a product of elementary reflectors.

See Further Details.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,M).

*D*

D is REAL array, dimension (NB)

The diagonal elements of the first NB rows and columns of

the reduced matrix. D(i) = A(i,i).

*E*

E is REAL array, dimension (NB)

The off-diagonal elements of the first NB rows and columns of

the reduced matrix.

*TAUQ*

TAUQ is REAL array, dimension (NB)

The scalar factors of the elementary reflectors which

represent the orthogonal matrix Q. See Further Details.

*TAUP*

TAUP is REAL array, dimension (NB)

The scalar factors of the elementary reflectors which

represent the orthogonal matrix P. See Further Details.

*X*

X is REAL array, dimension (LDX,NB)

The m-by-nb matrix X required to update the unreduced part

of A.

*LDX*

LDX is INTEGER

The leading dimension of the array X. LDX >= max(1,M).

*Y*

Y is REAL array, dimension (LDY,NB)

The n-by-nb matrix Y required to update the unreduced part

of A.

*LDY*

LDY is INTEGER

The leading dimension of the array Y. LDY >= max(1,N).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

The matrices Q and P are represented as products of elementary

reflectors:

Q = H(1) H(2) . . . H(nb) and P = G(1) G(2) . . . G(nb)

Each H(i) and G(i) has the form:

H(i) = I - tauq * v * v**T and G(i) = I - taup * u * u**T

where tauq and taup are real scalars, and v and u are real vectors.

If m >= n, v(1:i-1) = 0, v(i) = 1, and v(i:m) is stored on exit in

A(i:m,i); u(1:i) = 0, u(i+1) = 1, and u(i+1:n) is stored on exit in

A(i,i+1:n); tauq is stored in TAUQ(i) and taup in TAUP(i).

If m < n, v(1:i) = 0, v(i+1) = 1, and v(i+1:m) is stored on exit in

A(i+2:m,i); u(1:i-1) = 0, u(i) = 1, and u(i:n) is stored on exit in

A(i,i+1:n); tauq is stored in TAUQ(i) and taup in TAUP(i).

The elements of the vectors v and u together form the m-by-nb matrix

V and the nb-by-n matrix U**T which are needed, with X and Y, to apply

the transformation to the unreduced part of the matrix, using a block

update of the form: A := A - V*Y**T - X*U**T.

The contents of A on exit are illustrated by the following examples

with nb = 2:

m = 6 and n = 5 (m > n): m = 5 and n = 6 (m < n):

( 1 1 u1 u1 u1 ) ( 1 u1 u1 u1 u1 u1 )

( v1 1 1 u2 u2 ) ( 1 1 u2 u2 u2 u2 )

( v1 v2 a a a ) ( v1 1 a a a a )

( v1 v2 a a a ) ( v1 v2 a a a a )

( v1 v2 a a a ) ( v1 v2 a a a a )

( v1 v2 a a a )

where a denotes an element of the original matrix which is unchanged,

vi denotes an element of the vector defining H(i), and ui an element

of the vector defining G(i).

## subroutine slacn2 (integer N, real, dimension( * ) V, real, dimension( * ) X, integer, dimension( * ) ISGN, real EST, integer KASE, integer, dimension( 3 ) ISAVE)¶

**SLACN2** estimates the 1-norm of a square matrix, using
reverse communication for evaluating matrix-vector products.

**Purpose:**

SLACN2 estimates the 1-norm of a square, real matrix A.

Reverse communication is used for evaluating matrix-vector products.

**Parameters**

*N*

N is INTEGER

The order of the matrix. N >= 1.

*V*

V is REAL array, dimension (N)

On the final return, V = A*W, where EST = norm(V)/norm(W)

(W is not returned).

*X*

X is REAL array, dimension (N)

On an intermediate return, X should be overwritten by

A * X, if KASE=1,

A**T * X, if KASE=2,

and SLACN2 must be re-called with all the other parameters

unchanged.

*ISGN*

ISGN is INTEGER array, dimension (N)

*EST*

EST is REAL

On entry with KASE = 1 or 2 and ISAVE(1) = 3, EST should be

unchanged from the previous call to SLACN2.

On exit, EST is an estimate (a lower bound) for norm(A).

*KASE*

KASE is INTEGER

On the initial call to SLACN2, KASE should be 0.

On an intermediate return, KASE will be 1 or 2, indicating

whether X should be overwritten by A * X or A**T * X.

On the final return from SLACN2, KASE will again be 0.

*ISAVE*

ISAVE is INTEGER array, dimension (3)

ISAVE is used to save variables between calls to SLACN2

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

Originally named SONEST, dated March 16, 1988.

This is a thread safe version of SLACON, which uses the array ISAVE

in place of a SAVE statement, as follows:

SLACON SLACN2

JUMP ISAVE(1)

J ISAVE(2)

ITER ISAVE(3)

**Contributors:**

**References:**

a real or complex matrix, with applications to condition estimation', ACM Trans. Math. Soft., vol. 14, no. 4, pp. 381-396, December 1988.

## subroutine slacon (integer N, real, dimension( * ) V, real, dimension( * ) X, integer, dimension( * ) ISGN, real EST, integer KASE)¶

**SLACON** estimates the 1-norm of a square matrix, using
reverse communication for evaluating matrix-vector products.

**Purpose:**

SLACON estimates the 1-norm of a square, real matrix A.

Reverse communication is used for evaluating matrix-vector products.

**Parameters**

*N*

N is INTEGER

The order of the matrix. N >= 1.

*V*

V is REAL array, dimension (N)

On the final return, V = A*W, where EST = norm(V)/norm(W)

(W is not returned).

*X*

X is REAL array, dimension (N)

On an intermediate return, X should be overwritten by

A * X, if KASE=1,

A**T * X, if KASE=2,

and SLACON must be re-called with all the other parameters

unchanged.

*ISGN*

ISGN is INTEGER array, dimension (N)

*EST*

EST is REAL

On entry with KASE = 1 or 2 and JUMP = 3, EST should be

unchanged from the previous call to SLACON.

On exit, EST is an estimate (a lower bound) for norm(A).

*KASE*

KASE is INTEGER

On the initial call to SLACON, KASE should be 0.

On an intermediate return, KASE will be 1 or 2, indicating

whether X should be overwritten by A * X or A**T * X.

On the final return from SLACON, KASE will again be 0.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

Originally named SONEST, dated March 16, 1988.

**References:**

a real or complex matrix, with applications to condition estimation', ACM Trans. Math. Soft., vol. 14, no. 4, pp. 381-396, December 1988.

## subroutine sladiv (real A, real B, real C, real D, real P, real Q)¶

**SLADIV** performs complex division in real arithmetic,
avoiding unnecessary overflow.

**Purpose:**

SLADIV performs complex division in real arithmetic

a + i*b

p + i*q = ---------

c + i*d

The algorithm is due to Michael Baudin and Robert L. Smith

and can be found in the paper

"A Robust Complex Division in Scilab"

**Parameters**

*A*

A is REAL

*B*

B is REAL

*C*

C is REAL

*D*

D is REAL

The scalars a, b, c, and d in the above expression.

*P*

P is REAL

*Q*

Q is REAL

The scalars p and q in the above expression.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slaein (logical RIGHTV, logical NOINIT, integer N, real, dimension( ldh, * ) H, integer LDH, real WR, real WI, real, dimension( * ) VR, real, dimension( * ) VI, real, dimension( ldb, * ) B, integer LDB, real, dimension( * ) WORK, real EPS3, real SMLNUM, real BIGNUM, integer INFO)¶

**SLAEIN** computes a specified right or left eigenvector of an
upper Hessenberg matrix by inverse iteration.

**Purpose:**

SLAEIN uses inverse iteration to find a right or left eigenvector

corresponding to the eigenvalue (WR,WI) of a real upper Hessenberg

matrix H.

**Parameters**

*RIGHTV*

RIGHTV is LOGICAL

= .TRUE. : compute right eigenvector;

= .FALSE.: compute left eigenvector.

*NOINIT*

NOINIT is LOGICAL

= .TRUE. : no initial vector supplied in (VR,VI).

= .FALSE.: initial vector supplied in (VR,VI).

*N*

N is INTEGER

The order of the matrix H. N >= 0.

*H*

H is REAL array, dimension (LDH,N)

The upper Hessenberg matrix H.

*LDH*

LDH is INTEGER

The leading dimension of the array H. LDH >= max(1,N).

*WR*

WR is REAL

*WI*

WI is REAL

The real and imaginary parts of the eigenvalue of H whose

corresponding right or left eigenvector is to be computed.

*VR*

VR is REAL array, dimension (N)

*VI*

VI is REAL array, dimension (N)

On entry, if NOINIT = .FALSE. and WI = 0.0, VR must contain

a real starting vector for inverse iteration using the real

eigenvalue WR; if NOINIT = .FALSE. and WI.ne.0.0, VR and VI

must contain the real and imaginary parts of a complex

starting vector for inverse iteration using the complex

eigenvalue (WR,WI); otherwise VR and VI need not be set.

On exit, if WI = 0.0 (real eigenvalue), VR contains the

computed real eigenvector; if WI.ne.0.0 (complex eigenvalue),

VR and VI contain the real and imaginary parts of the

computed complex eigenvector. The eigenvector is normalized

so that the component of largest magnitude has magnitude 1;

here the magnitude of a complex number (x,y) is taken to be

|x| + |y|.

VI is not referenced if WI = 0.0.

*B*

B is REAL array, dimension (LDB,N)

*LDB*

LDB is INTEGER

The leading dimension of the array B. LDB >= N+1.

*WORK*

WORK is REAL array, dimension (N)

*EPS3*

EPS3 is REAL

A small machine-dependent value which is used to perturb

close eigenvalues, and to replace zero pivots.

*SMLNUM*

SMLNUM is REAL

A machine-dependent value close to the underflow threshold.

*BIGNUM*

BIGNUM is REAL

A machine-dependent value close to the overflow threshold.

*INFO*

INFO is INTEGER

= 0: successful exit

= 1: inverse iteration did not converge; VR is set to the

last iterate, and so is VI if WI.ne.0.0.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slaexc (logical WANTQ, integer N, real, dimension( ldt, * ) T, integer LDT, real, dimension( ldq, * ) Q, integer LDQ, integer J1, integer N1, integer N2, real, dimension( * ) WORK, integer INFO)¶

**SLAEXC** swaps adjacent diagonal blocks of a real upper
quasi-triangular matrix in Schur canonical form, by an orthogonal similarity
transformation.

**Purpose:**

SLAEXC swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in

an upper quasi-triangular matrix T by an orthogonal similarity

transformation.

T must be in Schur canonical form, that is, block upper triangular

with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block

has its diagonal elemnts equal and its off-diagonal elements of

opposite sign.

**Parameters**

*WANTQ*

WANTQ is LOGICAL

= .TRUE. : accumulate the transformation in the matrix Q;

= .FALSE.: do not accumulate the transformation.

*N*

N is INTEGER

The order of the matrix T. N >= 0.

*T*

T is REAL array, dimension (LDT,N)

On entry, the upper quasi-triangular matrix T, in Schur

canonical form.

On exit, the updated matrix T, again in Schur canonical form.

*LDT*

LDT is INTEGER

The leading dimension of the array T. LDT >= max(1,N).

*Q*

Q is REAL array, dimension (LDQ,N)

On entry, if WANTQ is .TRUE., the orthogonal matrix Q.

On exit, if WANTQ is .TRUE., the updated matrix Q.

If WANTQ is .FALSE., Q is not referenced.

*LDQ*

LDQ is INTEGER

The leading dimension of the array Q.

LDQ >= 1; and if WANTQ is .TRUE., LDQ >= N.

*J1*

J1 is INTEGER

The index of the first row of the first block T11.

*N1*

N1 is INTEGER

The order of the first block T11. N1 = 0, 1 or 2.

*N2*

N2 is INTEGER

The order of the second block T22. N2 = 0, 1 or 2.

*WORK*

WORK is REAL array, dimension (N)

*INFO*

INFO is INTEGER

= 0: successful exit

= 1: the transformed matrix T would be too far from Schur

form; the blocks are not swapped and T and Q are

unchanged.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slag2 (real, dimension( lda, * ) A, integer LDA, real, dimension( ldb, * ) B, integer LDB, real SAFMIN, real SCALE1, real SCALE2, real WR1, real WR2, real WI)¶

**SLAG2** computes the eigenvalues of a 2-by-2 generalized
eigenvalue problem, with scaling as necessary to avoid over-/underflow.

**Purpose:**

SLAG2 computes the eigenvalues of a 2 x 2 generalized eigenvalue

problem A - w B, with scaling as necessary to avoid over-/underflow.

The scaling factor "s" results in a modified eigenvalue equation

s A - w B

where s is a non-negative scaling factor chosen so that w, w B,

and s A do not overflow and, if possible, do not underflow, either.

**Parameters**

*A*

A is REAL array, dimension (LDA, 2)

On entry, the 2 x 2 matrix A. It is assumed that its 1-norm

is less than 1/SAFMIN. Entries less than

sqrt(SAFMIN)*norm(A) are subject to being treated as zero.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= 2.

*B*

B is REAL array, dimension (LDB, 2)

On entry, the 2 x 2 upper triangular matrix B. It is

assumed that the one-norm of B is less than 1/SAFMIN. The

diagonals should be at least sqrt(SAFMIN) times the largest

element of B (in absolute value); if a diagonal is smaller

than that, then +/- sqrt(SAFMIN) will be used instead of

that diagonal.

*LDB*

LDB is INTEGER

The leading dimension of the array B. LDB >= 2.

*SAFMIN*

SAFMIN is REAL

The smallest positive number s.t. 1/SAFMIN does not

overflow. (This should always be SLAMCH('S') -- it is an

argument in order to avoid having to call SLAMCH frequently.)

*SCALE1*

SCALE1 is REAL

A scaling factor used to avoid over-/underflow in the

eigenvalue equation which defines the first eigenvalue. If

the eigenvalues are complex, then the eigenvalues are

( WR1 +/- WI i ) / SCALE1 (which may lie outside the

exponent range of the machine), SCALE1=SCALE2, and SCALE1

will always be positive. If the eigenvalues are real, then

the first (real) eigenvalue is WR1 / SCALE1 , but this may

overflow or underflow, and in fact, SCALE1 may be zero or

less than the underflow threshold if the exact eigenvalue

is sufficiently large.

*SCALE2*

SCALE2 is REAL

A scaling factor used to avoid over-/underflow in the

eigenvalue equation which defines the second eigenvalue. If

the eigenvalues are complex, then SCALE2=SCALE1. If the

eigenvalues are real, then the second (real) eigenvalue is

WR2 / SCALE2 , but this may overflow or underflow, and in

fact, SCALE2 may be zero or less than the underflow

threshold if the exact eigenvalue is sufficiently large.

*WR1*

WR1 is REAL

If the eigenvalue is real, then WR1 is SCALE1 times the

eigenvalue closest to the (2,2) element of A B**(-1). If the

eigenvalue is complex, then WR1=WR2 is SCALE1 times the real

part of the eigenvalues.

*WR2*

WR2 is REAL

If the eigenvalue is real, then WR2 is SCALE2 times the

other eigenvalue. If the eigenvalue is complex, then

WR1=WR2 is SCALE1 times the real part of the eigenvalues.

*WI*

WI is REAL

If the eigenvalue is real, then WI is zero. If the

eigenvalue is complex, then WI is SCALE1 times the imaginary

part of the eigenvalues. WI will always be non-negative.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slags2 (logical UPPER, real A1, real A2, real A3, real B1, real B2, real B3, real CSU, real SNU, real CSV, real SNV, real CSQ, real SNQ)¶

**SLAGS2** computes 2-by-2 orthogonal matrices U, V, and Q, and
applies them to matrices A and B such that the rows of the transformed A and
B are parallel.

**Purpose:**

SLAGS2 computes 2-by-2 orthogonal matrices U, V and Q, such

that if ( UPPER ) then

U**T *A*Q = U**T *( A1 A2 )*Q = ( x 0 )

( 0 A3 ) ( x x )

and

V**T*B*Q = V**T *( B1 B2 )*Q = ( x 0 )

( 0 B3 ) ( x x )

or if ( .NOT.UPPER ) then

U**T *A*Q = U**T *( A1 0 )*Q = ( x x )

( A2 A3 ) ( 0 x )

and

V**T*B*Q = V**T*( B1 0 )*Q = ( x x )

( B2 B3 ) ( 0 x )

The rows of the transformed A and B are parallel, where

U = ( CSU SNU ), V = ( CSV SNV ), Q = ( CSQ SNQ )

( -SNU CSU ) ( -SNV CSV ) ( -SNQ CSQ )

Z**T denotes the transpose of Z.

**Parameters**

*UPPER*

UPPER is LOGICAL

= .TRUE.: the input matrices A and B are upper triangular.

= .FALSE.: the input matrices A and B are lower triangular.

*A1*

A1 is REAL

*A2*

A2 is REAL

*A3*

A3 is REAL

On entry, A1, A2 and A3 are elements of the input 2-by-2

upper (lower) triangular matrix A.

*B1*

B1 is REAL

*B2*

B2 is REAL

*B3*

B3 is REAL

On entry, B1, B2 and B3 are elements of the input 2-by-2

upper (lower) triangular matrix B.

*CSU*

CSU is REAL

*SNU*

SNU is REAL

The desired orthogonal matrix U.

*CSV*

CSV is REAL

*SNV*

SNV is REAL

The desired orthogonal matrix V.

*CSQ*

CSQ is REAL

*SNQ*

SNQ is REAL

The desired orthogonal matrix Q.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slagtm (character TRANS, integer N, integer NRHS, real ALPHA, real, dimension( * ) DL, real, dimension( * ) D, real, dimension( * ) DU, real, dimension( ldx, * ) X, integer LDX, real BETA, real, dimension( ldb, * ) B, integer LDB)¶

**SLAGTM** performs a matrix-matrix product of the form C =
αAB+βC, where A is a tridiagonal matrix, B and C are
rectangular matrices, and α and β are scalars, which may be 0,
1, or -1.

**Purpose:**

SLAGTM performs a matrix-vector product of the form

B := alpha * A * X + beta * B

where A is a tridiagonal matrix of order N, B and X are N by NRHS

matrices, and alpha and beta are real scalars, each of which may be

0., 1., or -1.

**Parameters**

*TRANS*

TRANS is CHARACTER*1

Specifies the operation applied to A.

= 'N': No transpose, B := alpha * A * X + beta * B

= 'T': Transpose, B := alpha * A'* X + beta * B

= 'C': Conjugate transpose = Transpose

*N*

N is INTEGER

The order of the matrix A. N >= 0.

*NRHS*

NRHS is INTEGER

The number of right hand sides, i.e., the number of columns

of the matrices X and B.

*ALPHA*

ALPHA is REAL

The scalar alpha. ALPHA must be 0., 1., or -1.; otherwise,

it is assumed to be 0.

*DL*

DL is REAL array, dimension (N-1)

The (n-1) sub-diagonal elements of T.

*D*

D is REAL array, dimension (N)

The diagonal elements of T.

*DU*

DU is REAL array, dimension (N-1)

The (n-1) super-diagonal elements of T.

*X*

X is REAL array, dimension (LDX,NRHS)

The N by NRHS matrix X.

*LDX*

LDX is INTEGER

The leading dimension of the array X. LDX >= max(N,1).

*BETA*

BETA is REAL

The scalar beta. BETA must be 0., 1., or -1.; otherwise,

it is assumed to be 1.

*B*

B is REAL array, dimension (LDB,NRHS)

On entry, the N by NRHS matrix B.

On exit, B is overwritten by the matrix expression

B := alpha * A * X + beta * B.

*LDB*

LDB is INTEGER

The leading dimension of the array B. LDB >= max(N,1).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slagv2 (real, dimension( lda, * ) A, integer LDA, real, dimension( ldb, * ) B, integer LDB, real, dimension( 2 ) ALPHAR, real, dimension( 2 ) ALPHAI, real, dimension( 2 ) BETA, real CSL, real SNL, real CSR, real SNR)¶

**SLAGV2** computes the Generalized Schur factorization of a
real 2-by-2 matrix pencil (A,B) where B is upper triangular.

**Purpose:**

SLAGV2 computes the Generalized Schur factorization of a real 2-by-2

matrix pencil (A,B) where B is upper triangular. This routine

computes orthogonal (rotation) matrices given by CSL, SNL and CSR,

SNR such that

1) if the pencil (A,B) has two real eigenvalues (include 0/0 or 1/0

types), then

[ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ]

[ 0 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ]

[ b11 b12 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ]

[ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ],

2) if the pencil (A,B) has a pair of complex conjugate eigenvalues,

then

[ a11 a12 ] := [ CSL SNL ] [ a11 a12 ] [ CSR -SNR ]

[ a21 a22 ] [ -SNL CSL ] [ a21 a22 ] [ SNR CSR ]

[ b11 0 ] := [ CSL SNL ] [ b11 b12 ] [ CSR -SNR ]

[ 0 b22 ] [ -SNL CSL ] [ 0 b22 ] [ SNR CSR ]

where b11 >= b22 > 0.

**Parameters**

*A*

A is REAL array, dimension (LDA, 2)

On entry, the 2 x 2 matrix A.

On exit, A is overwritten by the ``A-part'' of the

generalized Schur form.

*LDA*

LDA is INTEGER

THe leading dimension of the array A. LDA >= 2.

*B*

B is REAL array, dimension (LDB, 2)

On entry, the upper triangular 2 x 2 matrix B.

On exit, B is overwritten by the ``B-part'' of the

generalized Schur form.

*LDB*

LDB is INTEGER

THe leading dimension of the array B. LDB >= 2.

*ALPHAR*

ALPHAR is REAL array, dimension (2)

*ALPHAI*

ALPHAI is REAL array, dimension (2)

*BETA*

BETA is REAL array, dimension (2)

(ALPHAR(k)+i*ALPHAI(k))/BETA(k) are the eigenvalues of the

pencil (A,B), k=1,2, i = sqrt(-1). Note that BETA(k) may

be zero.

*CSL*

CSL is REAL

The cosine of the left rotation matrix.

*SNL*

SNL is REAL

The sine of the left rotation matrix.

*CSR*

CSR is REAL

The cosine of the right rotation matrix.

*SNR*

SNR is REAL

The sine of the right rotation matrix.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

## subroutine slahqr (logical WANTT, logical WANTZ, integer N, integer ILO, integer IHI, real, dimension( ldh, * ) H, integer LDH, real, dimension( * ) WR, real, dimension( * ) WI, integer ILOZ, integer IHIZ, real, dimension( ldz, * ) Z, integer LDZ, integer INFO)¶

**SLAHQR** computes the eigenvalues and Schur factorization of
an upper Hessenberg matrix, using the double-shift/single-shift QR
algorithm.

**Purpose:**

SLAHQR is an auxiliary routine called by SHSEQR to update the

eigenvalues and Schur decomposition already computed by SHSEQR, by

dealing with the Hessenberg submatrix in rows and columns ILO to

IHI.

**Parameters**

*WANTT*

WANTT is LOGICAL

= .TRUE. : the full Schur form T is required;

= .FALSE.: only eigenvalues are required.

*WANTZ*

WANTZ is LOGICAL

= .TRUE. : the matrix of Schur vectors Z is required;

= .FALSE.: Schur vectors are not required.

*N*

N is INTEGER

The order of the matrix H. N >= 0.

*ILO*

ILO is INTEGER

*IHI*

IHI is INTEGER

It is assumed that H is already upper quasi-triangular in

rows and columns IHI+1:N, and that H(ILO,ILO-1) = 0 (unless

ILO = 1). SLAHQR works primarily with the Hessenberg

submatrix in rows and columns ILO to IHI, but applies

transformations to all of H if WANTT is .TRUE..

1 <= ILO <= max(1,IHI); IHI <= N.

*H*

H is REAL array, dimension (LDH,N)

On entry, the upper Hessenberg matrix H.

On exit, if INFO is zero and if WANTT is .TRUE., H is upper

quasi-triangular in rows and columns ILO:IHI, with any

2-by-2 diagonal blocks in standard form. If INFO is zero

and WANTT is .FALSE., the contents of H are unspecified on

exit. The output state of H if INFO is nonzero is given

below under the description of INFO.

*LDH*

LDH is INTEGER

The leading dimension of the array H. LDH >= max(1,N).

*WR*

WR is REAL array, dimension (N)

*WI*

WI is REAL array, dimension (N)

The real and imaginary parts, respectively, of the computed

eigenvalues ILO to IHI are stored in the corresponding

elements of WR and WI. If two eigenvalues are computed as a

complex conjugate pair, they are stored in consecutive

elements of WR and WI, say the i-th and (i+1)th, with

WI(i) > 0 and WI(i+1) < 0. If WANTT is .TRUE., the

eigenvalues are stored in the same order as on the diagonal

of the Schur form returned in H, with WR(i) = H(i,i), and, if

H(i:i+1,i:i+1) is a 2-by-2 diagonal block,

WI(i) = sqrt(H(i+1,i)*H(i,i+1)) and WI(i+1) = -WI(i).

*ILOZ*

ILOZ is INTEGER

*IHIZ*

IHIZ is INTEGER

Specify the rows of Z to which transformations must be

applied if WANTZ is .TRUE..

1 <= ILOZ <= ILO; IHI <= IHIZ <= N.

*Z*

Z is REAL array, dimension (LDZ,N)

If WANTZ is .TRUE., on entry Z must contain the current

matrix Z of transformations accumulated by SHSEQR, and on

exit Z has been updated; transformations are applied only to

the submatrix Z(ILOZ:IHIZ,ILO:IHI).

If WANTZ is .FALSE., Z is not referenced.

*LDZ*

LDZ is INTEGER

The leading dimension of the array Z. LDZ >= max(1,N).

*INFO*

INFO is INTEGER

= 0: successful exit

> 0: If INFO = i, SLAHQR failed to compute all the

eigenvalues ILO to IHI in a total of 30 iterations

per eigenvalue; elements i+1:ihi of WR and WI

contain those eigenvalues which have been

successfully computed.

If INFO > 0 and WANTT is .FALSE., then on exit,

the remaining unconverged eigenvalues are the

eigenvalues of the upper Hessenberg matrix rows

and columns ILO through INFO of the final, output

value of H.

If INFO > 0 and WANTT is .TRUE., then on exit

(*) (initial value of H)*U = U*(final value of H)

where U is an orthogonal matrix. The final

value of H is upper Hessenberg and triangular in

rows and columns INFO+1 through IHI.

If INFO > 0 and WANTZ is .TRUE., then on exit

(final value of Z) = (initial value of Z)*U

where U is the orthogonal matrix in (*)

(regardless of the value of WANTT.)

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

02-96 Based on modifications by

David Day, Sandia National Laboratory, USA

12-04 Further modifications by

Ralph Byers, University of Kansas, USA

This is a modified version of SLAHQR from LAPACK version 3.0.

It is (1) more robust against overflow and underflow and

(2) adopts the more conservative Ahues & Tisseur stopping

criterion (LAWN 122, 1997).

## subroutine slahr2 (integer N, integer K, integer NB, real, dimension( lda, * ) A, integer LDA, real, dimension( nb ) TAU, real, dimension( ldt, nb ) T, integer LDT, real, dimension( ldy, nb ) Y, integer LDY)¶

**SLAHR2** reduces the specified number of first columns of a
general rectangular matrix A so that elements below the specified
subdiagonal are zero, and returns auxiliary matrices which are needed to
apply the transformation to the unreduced part of A.

**Purpose:**

SLAHR2 reduces the first NB columns of A real general n-BY-(n-k+1)

matrix A so that elements below the k-th subdiagonal are zero. The

reduction is performed by an orthogonal similarity transformation

Q**T * A * Q. The routine returns the matrices V and T which determine

Q as a block reflector I - V*T*V**T, and also the matrix Y = A * V * T.

This is an auxiliary routine called by SGEHRD.

**Parameters**

*N*

N is INTEGER

The order of the matrix A.

*K*

K is INTEGER

The offset for the reduction. Elements below the k-th

subdiagonal in the first NB columns are reduced to zero.

K < N.

*NB*

NB is INTEGER

The number of columns to be reduced.

*A*

A is REAL array, dimension (LDA,N-K+1)

On entry, the n-by-(n-k+1) general matrix A.

On exit, the elements on and above the k-th subdiagonal in

the first NB columns are overwritten with the corresponding

elements of the reduced matrix; the elements below the k-th

subdiagonal, with the array TAU, represent the matrix Q as a

product of elementary reflectors. The other columns of A are

unchanged. See Further Details.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,N).

*TAU*

TAU is REAL array, dimension (NB)

The scalar factors of the elementary reflectors. See Further

Details.

*T*

T is REAL array, dimension (LDT,NB)

The upper triangular matrix T.

*LDT*

LDT is INTEGER

The leading dimension of the array T. LDT >= NB.

*Y*

Y is REAL array, dimension (LDY,NB)

The n-by-nb matrix Y.

*LDY*

LDY is INTEGER

The leading dimension of the array Y. LDY >= N.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

The matrix Q is represented as a product of nb elementary reflectors

Q = H(1) H(2) . . . H(nb).

Each H(i) has the form

H(i) = I - tau * v * v**T

where tau is a real scalar, and v is a real vector with

v(1:i+k-1) = 0, v(i+k) = 1; v(i+k+1:n) is stored on exit in

A(i+k+1:n,i), and tau in TAU(i).

The elements of the vectors v together form the (n-k+1)-by-nb matrix

V which is needed, with T and Y, to apply the transformation to the

unreduced part of the matrix, using an update of the form:

A := (I - V*T*V**T) * (A - Y*V**T).

The contents of A on exit are illustrated by the following example

with n = 7, k = 3 and nb = 2:

( a a a a a )

( a a a a a )

( a a a a a )

( h h a a a )

( v1 h a a a )

( v1 v2 a a a )

( v1 v2 a a a )

where a denotes an element of the original matrix A, h denotes a

modified element of the upper Hessenberg matrix H, and vi denotes an

element of the vector defining H(i).

This subroutine is a slight modification of LAPACK-3.0's DLAHRD

incorporating improvements proposed by Quintana-Orti and Van de

Gejin. Note that the entries of A(1:K,2:NB) differ from those

returned by the original LAPACK-3.0's DLAHRD routine. (This

subroutine is not backward compatible with LAPACK-3.0's DLAHRD.)

**References:**

performance of reduction to Hessenberg form,' ACM Transactions on Mathematical Software, 32(2):180-194, June 2006.

## subroutine slaic1 (integer JOB, integer J, real, dimension( j ) X, real SEST, real, dimension( j ) W, real GAMMA, real SESTPR, real S, real C)¶

**SLAIC1** applies one step of incremental condition
estimation.

**Purpose:**

SLAIC1 applies one step of incremental condition estimation in

its simplest version:

Let x, twonorm(x) = 1, be an approximate singular vector of an j-by-j

lower triangular matrix L, such that

twonorm(L*x) = sest

Then SLAIC1 computes sestpr, s, c such that

the vector

[ s*x ]

xhat = [ c ]

is an approximate singular vector of

[ L 0 ]

Lhat = [ w**T gamma ]

in the sense that

twonorm(Lhat*xhat) = sestpr.

Depending on JOB, an estimate for the largest or smallest singular

value is computed.

Note that [s c]**T and sestpr**2 is an eigenpair of the system

diag(sest*sest, 0) + [alpha gamma] * [ alpha ]

[ gamma ]

where alpha = x**T*w.

**Parameters**

*JOB*

JOB is INTEGER

= 1: an estimate for the largest singular value is computed.

= 2: an estimate for the smallest singular value is computed.

*J*

J is INTEGER

Length of X and W

*X*

X is REAL array, dimension (J)

The j-vector x.

*SEST*

SEST is REAL

Estimated singular value of j by j matrix L

*W*

W is REAL array, dimension (J)

The j-vector w.

*GAMMA*

GAMMA is REAL

The diagonal element gamma.

*SESTPR*

SESTPR is REAL

Estimated singular value of (j+1) by (j+1) matrix Lhat.

*S*

S is REAL

Sine needed in forming xhat.

*C*

C is REAL

Cosine needed in forming xhat.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slaln2 (logical LTRANS, integer NA, integer NW, real SMIN, real CA, real, dimension( lda, * ) A, integer LDA, real D1, real D2, real, dimension( ldb, * ) B, integer LDB, real WR, real WI, real, dimension( ldx, * ) X, integer LDX, real SCALE, real XNORM, integer INFO)¶

**SLALN2** solves a 1-by-1 or 2-by-2 linear system of equations
of the specified form.

**Purpose:**

SLALN2 solves a system of the form (ca A - w D ) X = s B

or (ca A**T - w D) X = s B with possible scaling ("s") and

perturbation of A. (A**T means A-transpose.)

A is an NA x NA real matrix, ca is a real scalar, D is an NA x NA

real diagonal matrix, w is a real or complex value, and X and B are

NA x 1 matrices -- real if w is real, complex if w is complex. NA

may be 1 or 2.

If w is complex, X and B are represented as NA x 2 matrices,

the first column of each being the real part and the second

being the imaginary part.

"s" is a scaling factor (<= 1), computed by SLALN2, which is

so chosen that X can be computed without overflow. X is further

scaled if necessary to assure that norm(ca A - w D)*norm(X) is less

than overflow.

If both singular values of (ca A - w D) are less than SMIN,

SMIN*identity will be used instead of (ca A - w D). If only one

singular value is less than SMIN, one element of (ca A - w D) will be

perturbed enough to make the smallest singular value roughly SMIN.

If both singular values are at least SMIN, (ca A - w D) will not be

perturbed. In any case, the perturbation will be at most some small

multiple of max( SMIN, ulp*norm(ca A - w D) ). The singular values

are computed by infinity-norm approximations, and thus will only be

correct to a factor of 2 or so.

Note: all input quantities are assumed to be smaller than overflow

by a reasonable factor. (See BIGNUM.)

**Parameters**

*LTRANS*

LTRANS is LOGICAL

=.TRUE.: A-transpose will be used.

=.FALSE.: A will be used (not transposed.)

*NA*

NA is INTEGER

The size of the matrix A. It may (only) be 1 or 2.

*NW*

NW is INTEGER

1 if "w" is real, 2 if "w" is complex. It may only be 1

or 2.

*SMIN*

SMIN is REAL

The desired lower bound on the singular values of A. This

should be a safe distance away from underflow or overflow,

say, between (underflow/machine precision) and (machine

precision * overflow ). (See BIGNUM and ULP.)

*CA*

CA is REAL

The coefficient c, which A is multiplied by.

*A*

A is REAL array, dimension (LDA,NA)

The NA x NA matrix A.

*LDA*

LDA is INTEGER

The leading dimension of A. It must be at least NA.

*D1*

D1 is REAL

The 1,1 element in the diagonal matrix D.

*D2*

D2 is REAL

The 2,2 element in the diagonal matrix D. Not used if NA=1.

*B*

B is REAL array, dimension (LDB,NW)

The NA x NW matrix B (right-hand side). If NW=2 ("w" is

complex), column 1 contains the real part of B and column 2

contains the imaginary part.

*LDB*

LDB is INTEGER

The leading dimension of B. It must be at least NA.

*WR*

WR is REAL

The real part of the scalar "w".

*WI*

WI is REAL

The imaginary part of the scalar "w". Not used if NW=1.

*X*

X is REAL array, dimension (LDX,NW)

The NA x NW matrix X (unknowns), as computed by SLALN2.

If NW=2 ("w" is complex), on exit, column 1 will contain

the real part of X and column 2 will contain the imaginary

part.

*LDX*

LDX is INTEGER

The leading dimension of X. It must be at least NA.

*SCALE*

SCALE is REAL

The scale factor that B must be multiplied by to insure

that overflow does not occur when computing X. Thus,

(ca A - w D) X will be SCALE*B, not B (ignoring

perturbations of A.) It will be at most 1.

*XNORM*

XNORM is REAL

The infinity-norm of X, when X is regarded as an NA x NW

real matrix.

*INFO*

INFO is INTEGER

An error flag. It will be set to zero if no error occurs,

a negative number if an argument is in error, or a positive

number if ca A - w D had to be perturbed.

The possible values are:

= 0: No error occurred, and (ca A - w D) did not have to be

perturbed.

= 1: (ca A - w D) had to be perturbed to make its smallest

(or only) singular value greater than SMIN.

NOTE: In the interests of speed, this routine does not

check the inputs for errors.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## real function slangt (character NORM, integer N, real, dimension( * ) DL, real, dimension( * ) D, real, dimension( * ) DU)¶

**SLANGT** returns the value of the 1-norm, Frobenius norm,
infinity-norm, or the largest absolute value of any element of a general
tridiagonal matrix.

**Purpose:**

SLANGT returns the value of the one norm, or the Frobenius norm, or

the infinity norm, or the element of largest absolute value of a

real tridiagonal matrix A.

**Returns**

SLANGT = ( max(abs(A(i,j))), NORM = 'M' or 'm'

(

( norm1(A), NORM = '1', 'O' or 'o'

(

( normI(A), NORM = 'I' or 'i'

(

( normF(A), NORM = 'F', 'f', 'E' or 'e'

where norm1 denotes the one norm of a matrix (maximum column sum),

normI denotes the infinity norm of a matrix (maximum row sum) and

normF denotes the Frobenius norm of a matrix (square root of sum of

squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

**Parameters**

*NORM*

NORM is CHARACTER*1

Specifies the value to be returned in SLANGT as described

above.

*N*

N is INTEGER

The order of the matrix A. N >= 0. When N = 0, SLANGT is

set to zero.

*DL*

DL is REAL array, dimension (N-1)

The (n-1) sub-diagonal elements of A.

*D*

D is REAL array, dimension (N)

The diagonal elements of A.

*DU*

DU is REAL array, dimension (N-1)

The (n-1) super-diagonal elements of A.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## real function slanhs (character NORM, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) WORK)¶

**SLANHS** returns the value of the 1-norm, Frobenius norm,
infinity-norm, or the largest absolute value of any element of an upper
Hessenberg matrix.

**Purpose:**

SLANHS returns the value of the one norm, or the Frobenius norm, or

the infinity norm, or the element of largest absolute value of a

Hessenberg matrix A.

**Returns**

SLANHS = ( max(abs(A(i,j))), NORM = 'M' or 'm'

(

( norm1(A), NORM = '1', 'O' or 'o'

(

( normI(A), NORM = 'I' or 'i'

(

( normF(A), NORM = 'F', 'f', 'E' or 'e'

where norm1 denotes the one norm of a matrix (maximum column sum),

normI denotes the infinity norm of a matrix (maximum row sum) and

normF denotes the Frobenius norm of a matrix (square root of sum of

squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

**Parameters**

*NORM*

NORM is CHARACTER*1

Specifies the value to be returned in SLANHS as described

above.

*N*

N is INTEGER

The order of the matrix A. N >= 0. When N = 0, SLANHS is

set to zero.

*A*

A is REAL array, dimension (LDA,N)

The n by n upper Hessenberg matrix A; the part of A below the

first sub-diagonal is not referenced.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(N,1).

*WORK*

WORK is REAL array, dimension (MAX(1,LWORK)),

where LWORK >= N when NORM = 'I'; otherwise, WORK is not

referenced.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## real function slansb (character NORM, character UPLO, integer N, integer K, real, dimension( ldab, * ) AB, integer LDAB, real, dimension( * ) WORK)¶

**SLANSB** returns the value of the 1-norm, or the Frobenius
norm, or the infinity norm, or the element of largest absolute value of a
symmetric band matrix.

**Purpose:**

SLANSB returns the value of the one norm, or the Frobenius norm, or

the infinity norm, or the element of largest absolute value of an

n by n symmetric band matrix A, with k super-diagonals.

**Returns**

SLANSB = ( max(abs(A(i,j))), NORM = 'M' or 'm'

(

( norm1(A), NORM = '1', 'O' or 'o'

(

( normI(A), NORM = 'I' or 'i'

(

( normF(A), NORM = 'F', 'f', 'E' or 'e'

where norm1 denotes the one norm of a matrix (maximum column sum),

normI denotes the infinity norm of a matrix (maximum row sum) and

normF denotes the Frobenius norm of a matrix (square root of sum of

squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

**Parameters**

*NORM*

NORM is CHARACTER*1

Specifies the value to be returned in SLANSB as described

above.

*UPLO*

UPLO is CHARACTER*1

Specifies whether the upper or lower triangular part of the

band matrix A is supplied.

= 'U': Upper triangular part is supplied

= 'L': Lower triangular part is supplied

*N*

N is INTEGER

The order of the matrix A. N >= 0. When N = 0, SLANSB is

set to zero.

*K*

K is INTEGER

The number of super-diagonals or sub-diagonals of the

band matrix A. K >= 0.

*AB*

AB is REAL array, dimension (LDAB,N)

The upper or lower triangle of the symmetric band matrix A,

stored in the first K+1 rows of AB. The j-th column of A is

stored in the j-th column of the array AB as follows:

if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;

if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+k).

*LDAB*

LDAB is INTEGER

The leading dimension of the array AB. LDAB >= K+1.

*WORK*

WORK is REAL array, dimension (MAX(1,LWORK)),

where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,

WORK is not referenced.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## real function slansp (character NORM, character UPLO, integer N, real, dimension( * ) AP, real, dimension( * ) WORK)¶

**SLANSP** returns the value of the 1-norm, or the Frobenius
norm, or the infinity norm, or the element of largest absolute value of a
symmetric matrix supplied in packed form.

**Purpose:**

SLANSP returns the value of the one norm, or the Frobenius norm, or

the infinity norm, or the element of largest absolute value of a

real symmetric matrix A, supplied in packed form.

**Returns**

SLANSP = ( max(abs(A(i,j))), NORM = 'M' or 'm'

(

( norm1(A), NORM = '1', 'O' or 'o'

(

( normI(A), NORM = 'I' or 'i'

(

( normF(A), NORM = 'F', 'f', 'E' or 'e'

where norm1 denotes the one norm of a matrix (maximum column sum),

normI denotes the infinity norm of a matrix (maximum row sum) and

normF denotes the Frobenius norm of a matrix (square root of sum of

squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

**Parameters**

*NORM*

NORM is CHARACTER*1

Specifies the value to be returned in SLANSP as described

above.

*UPLO*

UPLO is CHARACTER*1

Specifies whether the upper or lower triangular part of the

symmetric matrix A is supplied.

= 'U': Upper triangular part of A is supplied

= 'L': Lower triangular part of A is supplied

*N*

N is INTEGER

The order of the matrix A. N >= 0. When N = 0, SLANSP is

set to zero.

*AP*

AP is REAL array, dimension (N*(N+1)/2)

The upper or lower triangle of the symmetric matrix A, packed

columnwise in a linear array. The j-th column of A is stored

in the array AP as follows:

if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;

if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

*WORK*

WORK is REAL array, dimension (MAX(1,LWORK)),

where LWORK >= N when NORM = 'I' or '1' or 'O'; otherwise,

WORK is not referenced.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## real function slantb (character NORM, character UPLO, character DIAG, integer N, integer K, real, dimension( ldab, * ) AB, integer LDAB, real, dimension( * ) WORK)¶

**SLANTB** returns the value of the 1-norm, or the Frobenius
norm, or the infinity norm, or the element of largest absolute value of a
triangular band matrix.

**Purpose:**

SLANTB returns the value of the one norm, or the Frobenius norm, or

the infinity norm, or the element of largest absolute value of an

n by n triangular band matrix A, with ( k + 1 ) diagonals.

**Returns**

SLANTB = ( max(abs(A(i,j))), NORM = 'M' or 'm'

(

( norm1(A), NORM = '1', 'O' or 'o'

(

( normI(A), NORM = 'I' or 'i'

(

( normF(A), NORM = 'F', 'f', 'E' or 'e'

where norm1 denotes the one norm of a matrix (maximum column sum),

normI denotes the infinity norm of a matrix (maximum row sum) and

normF denotes the Frobenius norm of a matrix (square root of sum of

squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

**Parameters**

*NORM*

NORM is CHARACTER*1

Specifies the value to be returned in SLANTB as described

above.

*UPLO*

UPLO is CHARACTER*1

Specifies whether the matrix A is upper or lower triangular.

= 'U': Upper triangular

= 'L': Lower triangular

*DIAG*

DIAG is CHARACTER*1

Specifies whether or not the matrix A is unit triangular.

= 'N': Non-unit triangular

= 'U': Unit triangular

*N*

N is INTEGER

The order of the matrix A. N >= 0. When N = 0, SLANTB is

set to zero.

*K*

K is INTEGER

The number of super-diagonals of the matrix A if UPLO = 'U',

or the number of sub-diagonals of the matrix A if UPLO = 'L'.

K >= 0.

*AB*

AB is REAL array, dimension (LDAB,N)

The upper or lower triangular band matrix A, stored in the

first k+1 rows of AB. The j-th column of A is stored

in the j-th column of the array AB as follows:

if UPLO = 'U', AB(k+1+i-j,j) = A(i,j) for max(1,j-k)<=i<=j;

if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+k).

Note that when DIAG = 'U', the elements of the array AB

corresponding to the diagonal elements of the matrix A are

not referenced, but are assumed to be one.

*LDAB*

LDAB is INTEGER

The leading dimension of the array AB. LDAB >= K+1.

*WORK*

WORK is REAL array, dimension (MAX(1,LWORK)),

where LWORK >= N when NORM = 'I'; otherwise, WORK is not

referenced.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## real function slantp (character NORM, character UPLO, character DIAG, integer N, real, dimension( * ) AP, real, dimension( * ) WORK)¶

**SLANTP** returns the value of the 1-norm, or the Frobenius
norm, or the infinity norm, or the element of largest absolute value of a
triangular matrix supplied in packed form.

**Purpose:**

SLANTP returns the value of the one norm, or the Frobenius norm, or

the infinity norm, or the element of largest absolute value of a

triangular matrix A, supplied in packed form.

**Returns**

SLANTP = ( max(abs(A(i,j))), NORM = 'M' or 'm'

(

( norm1(A), NORM = '1', 'O' or 'o'

(

( normI(A), NORM = 'I' or 'i'

(

( normF(A), NORM = 'F', 'f', 'E' or 'e'

where norm1 denotes the one norm of a matrix (maximum column sum),

normI denotes the infinity norm of a matrix (maximum row sum) and

normF denotes the Frobenius norm of a matrix (square root of sum of

squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

**Parameters**

*NORM*

NORM is CHARACTER*1

Specifies the value to be returned in SLANTP as described

above.

*UPLO*

UPLO is CHARACTER*1

Specifies whether the matrix A is upper or lower triangular.

= 'U': Upper triangular

= 'L': Lower triangular

*DIAG*

DIAG is CHARACTER*1

Specifies whether or not the matrix A is unit triangular.

= 'N': Non-unit triangular

= 'U': Unit triangular

*N*

N is INTEGER

The order of the matrix A. N >= 0. When N = 0, SLANTP is

set to zero.

*AP*

AP is REAL array, dimension (N*(N+1)/2)

The upper or lower triangular matrix A, packed columnwise in

a linear array. The j-th column of A is stored in the array

AP as follows:

if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;

if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

Note that when DIAG = 'U', the elements of the array AP

corresponding to the diagonal elements of the matrix A are

not referenced, but are assumed to be one.

*WORK*

WORK is REAL array, dimension (MAX(1,LWORK)),

where LWORK >= N when NORM = 'I'; otherwise, WORK is not

referenced.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## real function slantr (character NORM, character UPLO, character DIAG, integer M, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) WORK)¶

**SLANTR** returns the value of the 1-norm, or the Frobenius
norm, or the infinity norm, or the element of largest absolute value of a
trapezoidal or triangular matrix.

**Purpose:**

SLANTR returns the value of the one norm, or the Frobenius norm, or

the infinity norm, or the element of largest absolute value of a

trapezoidal or triangular matrix A.

**Returns**

SLANTR = ( max(abs(A(i,j))), NORM = 'M' or 'm'

(

( norm1(A), NORM = '1', 'O' or 'o'

(

( normI(A), NORM = 'I' or 'i'

(

( normF(A), NORM = 'F', 'f', 'E' or 'e'

where norm1 denotes the one norm of a matrix (maximum column sum),

normI denotes the infinity norm of a matrix (maximum row sum) and

normF denotes the Frobenius norm of a matrix (square root of sum of

squares). Note that max(abs(A(i,j))) is not a consistent matrix norm.

**Parameters**

*NORM*

NORM is CHARACTER*1

Specifies the value to be returned in SLANTR as described

above.

*UPLO*

UPLO is CHARACTER*1

Specifies whether the matrix A is upper or lower trapezoidal.

= 'U': Upper trapezoidal

= 'L': Lower trapezoidal

Note that A is triangular instead of trapezoidal if M = N.

*DIAG*

DIAG is CHARACTER*1

Specifies whether or not the matrix A has unit diagonal.

= 'N': Non-unit diagonal

= 'U': Unit diagonal

*M*

M is INTEGER

The number of rows of the matrix A. M >= 0, and if

UPLO = 'U', M <= N. When M = 0, SLANTR is set to zero.

*N*

N is INTEGER

The number of columns of the matrix A. N >= 0, and if

UPLO = 'L', N <= M. When N = 0, SLANTR is set to zero.

*A*

A is REAL array, dimension (LDA,N)

The trapezoidal matrix A (A is triangular if M = N).

If UPLO = 'U', the leading m by n upper trapezoidal part of

the array A contains the upper trapezoidal matrix, and the

strictly lower triangular part of A is not referenced.

If UPLO = 'L', the leading m by n lower trapezoidal part of

the array A contains the lower trapezoidal matrix, and the

strictly upper triangular part of A is not referenced. Note

that when DIAG = 'U', the diagonal elements of A are not

referenced and are assumed to be one.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(M,1).

*WORK*

WORK is REAL array, dimension (MAX(1,LWORK)),

where LWORK >= M when NORM = 'I'; otherwise, WORK is not

referenced.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slanv2 (real A, real B, real C, real D, real RT1R, real RT1I, real RT2R, real RT2I, real CS, real SN)¶

**SLANV2** computes the Schur factorization of a real 2-by-2
nonsymmetric matrix in standard form.

**Purpose:**

SLANV2 computes the Schur factorization of a real 2-by-2 nonsymmetric

matrix in standard form:

[ A B ] = [ CS -SN ] [ AA BB ] [ CS SN ]

[ C D ] [ SN CS ] [ CC DD ] [-SN CS ]

where either

1) CC = 0 so that AA and DD are real eigenvalues of the matrix, or

2) AA = DD and BB*CC < 0, so that AA + or - sqrt(BB*CC) are complex

conjugate eigenvalues.

**Parameters**

*A*

A is REAL

*B*

B is REAL

*C*

C is REAL

*D*

D is REAL

On entry, the elements of the input matrix.

On exit, they are overwritten by the elements of the

standardised Schur form.

*RT1R*

RT1R is REAL

*RT1I*

RT1I is REAL

*RT2R*

RT2R is REAL

*RT2I*

RT2I is REAL

The real and imaginary parts of the eigenvalues. If the

eigenvalues are a complex conjugate pair, RT1I > 0.

*CS*

CS is REAL

*SN*

SN is REAL

Parameters of the rotation matrix.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

Modified by V. Sima, Research Institute for Informatics, Bucharest,

Romania, to reduce the risk of cancellation errors,

when computing real eigenvalues, and to ensure, if possible, that

abs(RT1R) >= abs(RT2R).

## subroutine slapll (integer N, real, dimension( * ) X, integer INCX, real, dimension( * ) Y, integer INCY, real SSMIN)¶

**SLAPLL** measures the linear dependence of two vectors.

**Purpose:**

Given two column vectors X and Y, let

A = ( X Y ).

The subroutine first computes the QR factorization of A = Q*R,

and then computes the SVD of the 2-by-2 upper triangular matrix R.

The smaller singular value of R is returned in SSMIN, which is used

as the measurement of the linear dependency of the vectors X and Y.

**Parameters**

*N*

N is INTEGER

The length of the vectors X and Y.

*X*

X is REAL array,

dimension (1+(N-1)*INCX)

On entry, X contains the N-vector X.

On exit, X is overwritten.

*INCX*

INCX is INTEGER

The increment between successive elements of X. INCX > 0.

*Y*

Y is REAL array,

dimension (1+(N-1)*INCY)

On entry, Y contains the N-vector Y.

On exit, Y is overwritten.

*INCY*

INCY is INTEGER

The increment between successive elements of Y. INCY > 0.

*SSMIN*

SSMIN is REAL

The smallest singular value of the N-by-2 matrix A = ( X Y ).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slapmr (logical FORWRD, integer M, integer N, real, dimension( ldx, * ) X, integer LDX, integer, dimension( * ) K)¶

**SLAPMR** rearranges rows of a matrix as specified by a
permutation vector.

**Purpose:**

SLAPMR rearranges the rows of the M by N matrix X as specified

by the permutation K(1),K(2),...,K(M) of the integers 1,...,M.

If FORWRD = .TRUE., forward permutation:

X(K(I),*) is moved X(I,*) for I = 1,2,...,M.

If FORWRD = .FALSE., backward permutation:

X(I,*) is moved to X(K(I),*) for I = 1,2,...,M.

**Parameters**

*FORWRD*

FORWRD is LOGICAL

= .TRUE., forward permutation

= .FALSE., backward permutation

*M*

M is INTEGER

The number of rows of the matrix X. M >= 0.

*N*

N is INTEGER

The number of columns of the matrix X. N >= 0.

*X*

X is REAL array, dimension (LDX,N)

On entry, the M by N matrix X.

On exit, X contains the permuted matrix X.

*LDX*

LDX is INTEGER

The leading dimension of the array X, LDX >= MAX(1,M).

*K*

K is INTEGER array, dimension (M)

On entry, K contains the permutation vector. K is used as

internal workspace, but reset to its original value on

output.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slapmt (logical FORWRD, integer M, integer N, real, dimension( ldx, * ) X, integer LDX, integer, dimension( * ) K)¶

**SLAPMT** performs a forward or backward permutation of the
columns of a matrix.

**Purpose:**

SLAPMT rearranges the columns of the M by N matrix X as specified

by the permutation K(1),K(2),...,K(N) of the integers 1,...,N.

If FORWRD = .TRUE., forward permutation:

X(*,K(J)) is moved X(*,J) for J = 1,2,...,N.

If FORWRD = .FALSE., backward permutation:

X(*,J) is moved to X(*,K(J)) for J = 1,2,...,N.

**Parameters**

*FORWRD*

FORWRD is LOGICAL

= .TRUE., forward permutation

= .FALSE., backward permutation

*M*

M is INTEGER

The number of rows of the matrix X. M >= 0.

*N*

N is INTEGER

The number of columns of the matrix X. N >= 0.

*X*

X is REAL array, dimension (LDX,N)

On entry, the M by N matrix X.

On exit, X contains the permuted matrix X.

*LDX*

LDX is INTEGER

The leading dimension of the array X, LDX >= MAX(1,M).

*K*

K is INTEGER array, dimension (N)

On entry, K contains the permutation vector. K is used as

internal workspace, but reset to its original value on

output.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slaqp2 (integer M, integer N, integer OFFSET, real, dimension( lda, * ) A, integer LDA, integer, dimension( * ) JPVT, real, dimension( * ) TAU, real, dimension( * ) VN1, real, dimension( * ) VN2, real, dimension( * ) WORK)¶

**SLAQP2** computes a QR factorization with column pivoting of
the matrix block.

**Purpose:**

SLAQP2 computes a QR factorization with column pivoting of

the block A(OFFSET+1:M,1:N).

The block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

**Parameters**

*M*

M is INTEGER

The number of rows of the matrix A. M >= 0.

*N*

N is INTEGER

The number of columns of the matrix A. N >= 0.

*OFFSET*

OFFSET is INTEGER

The number of rows of the matrix A that must be pivoted

but no factorized. OFFSET >= 0.

*A*

A is REAL array, dimension (LDA,N)

On entry, the M-by-N matrix A.

On exit, the upper triangle of block A(OFFSET+1:M,1:N) is

the triangular factor obtained; the elements in block

A(OFFSET+1:M,1:N) below the diagonal, together with the

array TAU, represent the orthogonal matrix Q as a product of

elementary reflectors. Block A(1:OFFSET,1:N) has been

accordingly pivoted, but no factorized.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,M).

*JPVT*

JPVT is INTEGER array, dimension (N)

On entry, if JPVT(i) .ne. 0, the i-th column of A is permuted

to the front of A*P (a leading column); if JPVT(i) = 0,

the i-th column of A is a free column.

On exit, if JPVT(i) = k, then the i-th column of A*P

was the k-th column of A.

*TAU*

TAU is REAL array, dimension (min(M,N))

The scalar factors of the elementary reflectors.

*VN1*

VN1 is REAL array, dimension (N)

The vector with the partial column norms.

*VN2*

VN2 is REAL array, dimension (N)

The vector with the exact column norms.

*WORK*

WORK is REAL array, dimension (N)

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

Partial column norm updating strategy modified on April 2011 Z. Drmac and Z. Bujanovic, Dept. of Mathematics, University of Zagreb, Croatia.

**References:**

## subroutine slaqps (integer M, integer N, integer OFFSET, integer NB, integer KB, real, dimension( lda, * ) A, integer LDA, integer, dimension( * ) JPVT, real, dimension( * ) TAU, real, dimension( * ) VN1, real, dimension( * ) VN2, real, dimension( * ) AUXV, real, dimension( ldf, * ) F, integer LDF)¶

**SLAQPS** computes a step of QR factorization with column
pivoting of a real m-by-n matrix A by using BLAS level 3.

**Purpose:**

SLAQPS computes a step of QR factorization with column pivoting

of a real M-by-N matrix A by using Blas-3. It tries to factorize

NB columns from A starting from the row OFFSET+1, and updates all

of the matrix with Blas-3 xGEMM.

In some cases, due to catastrophic cancellations, it cannot

factorize NB columns. Hence, the actual number of factorized

columns is returned in KB.

Block A(1:OFFSET,1:N) is accordingly pivoted, but not factorized.

**Parameters**

*M*

M is INTEGER

The number of rows of the matrix A. M >= 0.

*N*

N is INTEGER

The number of columns of the matrix A. N >= 0

*OFFSET*

OFFSET is INTEGER

The number of rows of A that have been factorized in

previous steps.

*NB*

NB is INTEGER

The number of columns to factorize.

*KB*

KB is INTEGER

The number of columns actually factorized.

*A*

A is REAL array, dimension (LDA,N)

On entry, the M-by-N matrix A.

On exit, block A(OFFSET+1:M,1:KB) is the triangular

factor obtained and block A(1:OFFSET,1:N) has been

accordingly pivoted, but no factorized.

The rest of the matrix, block A(OFFSET+1:M,KB+1:N) has

been updated.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,M).

*JPVT*

JPVT is INTEGER array, dimension (N)

JPVT(I) = K <==> Column K of the full matrix A has been

permuted into position I in AP.

*TAU*

TAU is REAL array, dimension (KB)

The scalar factors of the elementary reflectors.

*VN1*

VN1 is REAL array, dimension (N)

The vector with the partial column norms.

*VN2*

VN2 is REAL array, dimension (N)

The vector with the exact column norms.

*AUXV*

AUXV is REAL array, dimension (NB)

Auxiliary vector.

*F*

F is REAL array, dimension (LDF,NB)

Matrix F**T = L*Y**T*A.

*LDF*

LDF is INTEGER

The leading dimension of the array F. LDF >= max(1,N).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

Partial column norm updating strategy modified on April 2011 Z. Drmac and Z.
Bujanovic, Dept. of Mathematics, University of Zagreb, Croatia.

**References:**

## subroutine slaqr0 (logical WANTT, logical WANTZ, integer N, integer ILO, integer IHI, real, dimension( ldh, * ) H, integer LDH, real, dimension( * ) WR, real, dimension( * ) WI, integer ILOZ, integer IHIZ, real, dimension( ldz, * ) Z, integer LDZ, real, dimension( * ) WORK, integer LWORK, integer INFO)¶

**SLAQR0** computes the eigenvalues of a Hessenberg matrix, and
optionally the matrices from the Schur decomposition.

**Purpose:**

SLAQR0 computes the eigenvalues of a Hessenberg matrix H

and, optionally, the matrices T and Z from the Schur decomposition

H = Z T Z**T, where T is an upper quasi-triangular matrix (the

Schur form), and Z is the orthogonal matrix of Schur vectors.

Optionally Z may be postmultiplied into an input orthogonal

matrix Q so that this routine can give the Schur factorization

of a matrix A which has been reduced to the Hessenberg form H

by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.

**Parameters**

*WANTT*

WANTT is LOGICAL

= .TRUE. : the full Schur form T is required;

= .FALSE.: only eigenvalues are required.

*WANTZ*

WANTZ is LOGICAL

= .TRUE. : the matrix of Schur vectors Z is required;

= .FALSE.: Schur vectors are not required.

*N*

N is INTEGER

The order of the matrix H. N >= 0.

*ILO*

ILO is INTEGER

*IHI*

IHI is INTEGER

It is assumed that H is already upper triangular in rows

and columns 1:ILO-1 and IHI+1:N and, if ILO > 1,

H(ILO,ILO-1) is zero. ILO and IHI are normally set by a

previous call to SGEBAL, and then passed to SGEHRD when the

matrix output by SGEBAL is reduced to Hessenberg form.

Otherwise, ILO and IHI should be set to 1 and N,

respectively. If N > 0, then 1 <= ILO <= IHI <= N.

If N = 0, then ILO = 1 and IHI = 0.

*H*

H is REAL array, dimension (LDH,N)

On entry, the upper Hessenberg matrix H.

On exit, if INFO = 0 and WANTT is .TRUE., then H contains

the upper quasi-triangular matrix T from the Schur

decomposition (the Schur form); 2-by-2 diagonal blocks

(corresponding to complex conjugate pairs of eigenvalues)

are returned in standard form, with H(i,i) = H(i+1,i+1)

and H(i+1,i)*H(i,i+1) < 0. If INFO = 0 and WANTT is

.FALSE., then the contents of H are unspecified on exit.

(The output value of H when INFO > 0 is given under the

description of INFO below.)

This subroutine may explicitly set H(i,j) = 0 for i > j and

j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N.

*LDH*

LDH is INTEGER

The leading dimension of the array H. LDH >= max(1,N).

*WR*

WR is REAL array, dimension (IHI)

*WI*

WI is REAL array, dimension (IHI)

The real and imaginary parts, respectively, of the computed

eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)

and WI(ILO:IHI). If two eigenvalues are computed as a

complex conjugate pair, they are stored in consecutive

elements of WR and WI, say the i-th and (i+1)th, with

WI(i) > 0 and WI(i+1) < 0. If WANTT is .TRUE., then

the eigenvalues are stored in the same order as on the

diagonal of the Schur form returned in H, with

WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal

block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and

WI(i+1) = -WI(i).

*ILOZ*

ILOZ is INTEGER

*IHIZ*

IHIZ is INTEGER

Specify the rows of Z to which transformations must be

applied if WANTZ is .TRUE..

1 <= ILOZ <= ILO; IHI <= IHIZ <= N.

*Z*

Z is REAL array, dimension (LDZ,IHI)

If WANTZ is .FALSE., then Z is not referenced.

If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is

replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the

orthogonal Schur factor of H(ILO:IHI,ILO:IHI).

(The output value of Z when INFO > 0 is given under

the description of INFO below.)

*LDZ*

LDZ is INTEGER

The leading dimension of the array Z. if WANTZ is .TRUE.

then LDZ >= MAX(1,IHIZ). Otherwise, LDZ >= 1.

*WORK*

WORK is REAL array, dimension LWORK

On exit, if LWORK = -1, WORK(1) returns an estimate of

the optimal value for LWORK.

*LWORK*

LWORK is INTEGER

The dimension of the array WORK. LWORK >= max(1,N)

is sufficient, but LWORK typically as large as 6*N may

be required for optimal performance. A workspace query

to determine the optimal workspace size is recommended.

If LWORK = -1, then SLAQR0 does a workspace query.

In this case, SLAQR0 checks the input parameters and

estimates the optimal workspace size for the given

values of N, ILO and IHI. The estimate is returned

in WORK(1). No error message related to LWORK is

issued by XERBLA. Neither H nor Z are accessed.

*INFO*

INFO is INTEGER

= 0: successful exit

> 0: if INFO = i, SLAQR0 failed to compute all of

the eigenvalues. Elements 1:ilo-1 and i+1:n of WR

and WI contain those eigenvalues which have been

successfully computed. (Failures are rare.)

If INFO > 0 and WANT is .FALSE., then on exit,

the remaining unconverged eigenvalues are the eigen-

values of the upper Hessenberg matrix rows and

columns ILO through INFO of the final, output

value of H.

If INFO > 0 and WANTT is .TRUE., then on exit

(*) (initial value of H)*U = U*(final value of H)

where U is an orthogonal matrix. The final

value of H is upper Hessenberg and quasi-triangular

in rows and columns INFO+1 through IHI.

If INFO > 0 and WANTZ is .TRUE., then on exit

(final value of Z(ILO:IHI,ILOZ:IHIZ)

= (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U

where U is the orthogonal matrix in (*) (regard-

less of the value of WANTT.)

If INFO > 0 and WANTZ is .FALSE., then Z is not

accessed.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

**References:**

K. Braman, R. Byers and R. Mathias, The Multi-Shift QR

Algorithm Part I: Maintaining Well Focused Shifts, and Level 3

Performance, SIAM Journal of Matrix Analysis, volume 23, pages

929--947, 2002.

K. Braman, R. Byers and R. Mathias, The Multi-Shift QR Algorithm Part II:
Aggressive Early Deflation, SIAM Journal of Matrix Analysis, volume 23,
pages 948--973, 2002.

## subroutine slaqr1 (integer N, real, dimension( ldh, * ) H, integer LDH, real SR1, real SI1, real SR2, real SI2, real, dimension( * ) V)¶

**SLAQR1** sets a scalar multiple of the first column of the
product of 2-by-2 or 3-by-3 matrix H and specified shifts.

**Purpose:**

Given a 2-by-2 or 3-by-3 matrix H, SLAQR1 sets v to a

scalar multiple of the first column of the product

(*) K = (H - (sr1 + i*si1)*I)*(H - (sr2 + i*si2)*I)

scaling to avoid overflows and most underflows. It

is assumed that either

1) sr1 = sr2 and si1 = -si2

or

2) si1 = si2 = 0.

This is useful for starting double implicit shift bulges

in the QR algorithm.

**Parameters**

*N*

N is INTEGER

Order of the matrix H. N must be either 2 or 3.

*H*

H is REAL array, dimension (LDH,N)

The 2-by-2 or 3-by-3 matrix H in (*).

*LDH*

LDH is INTEGER

The leading dimension of H as declared in

the calling procedure. LDH >= N

*SR1*

SR1 is REAL

*SI1*

SI1 is REAL

*SR2*

SR2 is REAL

*SI2*

SI2 is REAL

The shifts in (*).

*V*

V is REAL array, dimension (N)

A scalar multiple of the first column of the

matrix K in (*).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

## subroutine slaqr2 (logical WANTT, logical WANTZ, integer N, integer KTOP, integer KBOT, integer NW, real, dimension( ldh, * ) H, integer LDH, integer ILOZ, integer IHIZ, real, dimension( ldz, * ) Z, integer LDZ, integer NS, integer ND, real, dimension( * ) SR, real, dimension( * ) SI, real, dimension( ldv, * ) V, integer LDV, integer NH, real, dimension( ldt, * ) T, integer LDT, integer NV, real, dimension( ldwv, * ) WV, integer LDWV, real, dimension( * ) WORK, integer LWORK)¶

**SLAQR2** performs the orthogonal similarity transformation of
a Hessenberg matrix to detect and deflate fully converged eigenvalues from a
trailing principal submatrix (aggressive early deflation).

**Purpose:**

SLAQR2 is identical to SLAQR3 except that it avoids

recursion by calling SLAHQR instead of SLAQR4.

Aggressive early deflation:

This subroutine accepts as input an upper Hessenberg matrix

H and performs an orthogonal similarity transformation

designed to detect and deflate fully converged eigenvalues from

a trailing principal submatrix. On output H has been over-

written by a new Hessenberg matrix that is a perturbation of

an orthogonal similarity transformation of H. It is to be

hoped that the final version of H has many zero subdiagonal

entries.

**Parameters**

*WANTT*

WANTT is LOGICAL

If .TRUE., then the Hessenberg matrix H is fully updated

so that the quasi-triangular Schur factor may be

computed (in cooperation with the calling subroutine).

If .FALSE., then only enough of H is updated to preserve

the eigenvalues.

*WANTZ*

WANTZ is LOGICAL

If .TRUE., then the orthogonal matrix Z is updated so

so that the orthogonal Schur factor may be computed

(in cooperation with the calling subroutine).

If .FALSE., then Z is not referenced.

*N*

N is INTEGER

The order of the matrix H and (if WANTZ is .TRUE.) the

order of the orthogonal matrix Z.

*KTOP*

KTOP is INTEGER

It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.

KBOT and KTOP together determine an isolated block

along the diagonal of the Hessenberg matrix.

*KBOT*

KBOT is INTEGER

It is assumed without a check that either

KBOT = N or H(KBOT+1,KBOT)=0. KBOT and KTOP together

determine an isolated block along the diagonal of the

Hessenberg matrix.

*NW*

NW is INTEGER

Deflation window size. 1 <= NW <= (KBOT-KTOP+1).

*H*

H is REAL array, dimension (LDH,N)

On input the initial N-by-N section of H stores the

Hessenberg matrix undergoing aggressive early deflation.

On output H has been transformed by an orthogonal

similarity transformation, perturbed, and the returned

to Hessenberg form that (it is to be hoped) has some

zero subdiagonal entries.

*LDH*

LDH is INTEGER

Leading dimension of H just as declared in the calling

subroutine. N <= LDH

*ILOZ*

ILOZ is INTEGER

*IHIZ*

IHIZ is INTEGER

Specify the rows of Z to which transformations must be

applied if WANTZ is .TRUE.. 1 <= ILOZ <= IHIZ <= N.

*Z*

Z is REAL array, dimension (LDZ,N)

IF WANTZ is .TRUE., then on output, the orthogonal

similarity transformation mentioned above has been

accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.

If WANTZ is .FALSE., then Z is unreferenced.

*LDZ*

LDZ is INTEGER

The leading dimension of Z just as declared in the

calling subroutine. 1 <= LDZ.

*NS*

NS is INTEGER

The number of unconverged (ie approximate) eigenvalues

returned in SR and SI that may be used as shifts by the

calling subroutine.

*ND*

ND is INTEGER

The number of converged eigenvalues uncovered by this

subroutine.

*SR*

SR is REAL array, dimension (KBOT)

*SI*

SI is REAL array, dimension (KBOT)

On output, the real and imaginary parts of approximate

eigenvalues that may be used for shifts are stored in

SR(KBOT-ND-NS+1) through SR(KBOT-ND) and

SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.

The real and imaginary parts of converged eigenvalues

are stored in SR(KBOT-ND+1) through SR(KBOT) and

SI(KBOT-ND+1) through SI(KBOT), respectively.

*V*

V is REAL array, dimension (LDV,NW)

An NW-by-NW work array.

*LDV*

LDV is INTEGER

The leading dimension of V just as declared in the

calling subroutine. NW <= LDV

*NH*

NH is INTEGER

The number of columns of T. NH >= NW.

*T*

T is REAL array, dimension (LDT,NW)

*LDT*

LDT is INTEGER

The leading dimension of T just as declared in the

calling subroutine. NW <= LDT

*NV*

NV is INTEGER

The number of rows of work array WV available for

workspace. NV >= NW.

*WV*

WV is REAL array, dimension (LDWV,NW)

*LDWV*

LDWV is INTEGER

The leading dimension of W just as declared in the

calling subroutine. NW <= LDV

*WORK*

WORK is REAL array, dimension (LWORK)

On exit, WORK(1) is set to an estimate of the optimal value

of LWORK for the given values of N, NW, KTOP and KBOT.

*LWORK*

LWORK is INTEGER

The dimension of the work array WORK. LWORK = 2*NW

suffices, but greater efficiency may result from larger

values of LWORK.

If LWORK = -1, then a workspace query is assumed; SLAQR2

only estimates the optimal workspace size for the given

values of N, NW, KTOP and KBOT. The estimate is returned

in WORK(1). No error message related to LWORK is issued

by XERBLA. Neither H nor Z are accessed.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

## subroutine slaqr3 (logical WANTT, logical WANTZ, integer N, integer KTOP, integer KBOT, integer NW, real, dimension( ldh, * ) H, integer LDH, integer ILOZ, integer IHIZ, real, dimension( ldz, * ) Z, integer LDZ, integer NS, integer ND, real, dimension( * ) SR, real, dimension( * ) SI, real, dimension( ldv, * ) V, integer LDV, integer NH, real, dimension( ldt, * ) T, integer LDT, integer NV, real, dimension( ldwv, * ) WV, integer LDWV, real, dimension( * ) WORK, integer LWORK)¶

**SLAQR3** performs the orthogonal similarity transformation of
a Hessenberg matrix to detect and deflate fully converged eigenvalues from a
trailing principal submatrix (aggressive early deflation).

**Purpose:**

Aggressive early deflation:

SLAQR3 accepts as input an upper Hessenberg matrix

H and performs an orthogonal similarity transformation

designed to detect and deflate fully converged eigenvalues from

a trailing principal submatrix. On output H has been over-

written by a new Hessenberg matrix that is a perturbation of

an orthogonal similarity transformation of H. It is to be

hoped that the final version of H has many zero subdiagonal

entries.

**Parameters**

*WANTT*

WANTT is LOGICAL

If .TRUE., then the Hessenberg matrix H is fully updated

so that the quasi-triangular Schur factor may be

computed (in cooperation with the calling subroutine).

If .FALSE., then only enough of H is updated to preserve

the eigenvalues.

*WANTZ*

WANTZ is LOGICAL

If .TRUE., then the orthogonal matrix Z is updated so

so that the orthogonal Schur factor may be computed

(in cooperation with the calling subroutine).

If .FALSE., then Z is not referenced.

*N*

N is INTEGER

The order of the matrix H and (if WANTZ is .TRUE.) the

order of the orthogonal matrix Z.

*KTOP*

KTOP is INTEGER

It is assumed that either KTOP = 1 or H(KTOP,KTOP-1)=0.

KBOT and KTOP together determine an isolated block

along the diagonal of the Hessenberg matrix.

*KBOT*

KBOT is INTEGER

It is assumed without a check that either

KBOT = N or H(KBOT+1,KBOT)=0. KBOT and KTOP together

determine an isolated block along the diagonal of the

Hessenberg matrix.

*NW*

NW is INTEGER

Deflation window size. 1 <= NW <= (KBOT-KTOP+1).

*H*

H is REAL array, dimension (LDH,N)

On input the initial N-by-N section of H stores the

Hessenberg matrix undergoing aggressive early deflation.

On output H has been transformed by an orthogonal

similarity transformation, perturbed, and the returned

to Hessenberg form that (it is to be hoped) has some

zero subdiagonal entries.

*LDH*

LDH is INTEGER

Leading dimension of H just as declared in the calling

subroutine. N <= LDH

*ILOZ*

ILOZ is INTEGER

*IHIZ*

IHIZ is INTEGER

Specify the rows of Z to which transformations must be

applied if WANTZ is .TRUE.. 1 <= ILOZ <= IHIZ <= N.

*Z*

Z is REAL array, dimension (LDZ,N)

IF WANTZ is .TRUE., then on output, the orthogonal

similarity transformation mentioned above has been

accumulated into Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.

If WANTZ is .FALSE., then Z is unreferenced.

*LDZ*

LDZ is INTEGER

The leading dimension of Z just as declared in the

calling subroutine. 1 <= LDZ.

*NS*

NS is INTEGER

The number of unconverged (ie approximate) eigenvalues

returned in SR and SI that may be used as shifts by the

calling subroutine.

*ND*

ND is INTEGER

The number of converged eigenvalues uncovered by this

subroutine.

*SR*

SR is REAL array, dimension (KBOT)

*SI*

SI is REAL array, dimension (KBOT)

On output, the real and imaginary parts of approximate

eigenvalues that may be used for shifts are stored in

SR(KBOT-ND-NS+1) through SR(KBOT-ND) and

SI(KBOT-ND-NS+1) through SI(KBOT-ND), respectively.

The real and imaginary parts of converged eigenvalues

are stored in SR(KBOT-ND+1) through SR(KBOT) and

SI(KBOT-ND+1) through SI(KBOT), respectively.

*V*

V is REAL array, dimension (LDV,NW)

An NW-by-NW work array.

*LDV*

LDV is INTEGER

The leading dimension of V just as declared in the

calling subroutine. NW <= LDV

*NH*

NH is INTEGER

The number of columns of T. NH >= NW.

*T*

T is REAL array, dimension (LDT,NW)

*LDT*

LDT is INTEGER

The leading dimension of T just as declared in the

calling subroutine. NW <= LDT

*NV*

NV is INTEGER

The number of rows of work array WV available for

workspace. NV >= NW.

*WV*

WV is REAL array, dimension (LDWV,NW)

*LDWV*

LDWV is INTEGER

The leading dimension of W just as declared in the

calling subroutine. NW <= LDV

*WORK*

WORK is REAL array, dimension (LWORK)

On exit, WORK(1) is set to an estimate of the optimal value

of LWORK for the given values of N, NW, KTOP and KBOT.

*LWORK*

LWORK is INTEGER

The dimension of the work array WORK. LWORK = 2*NW

suffices, but greater efficiency may result from larger

values of LWORK.

If LWORK = -1, then a workspace query is assumed; SLAQR3

only estimates the optimal workspace size for the given

values of N, NW, KTOP and KBOT. The estimate is returned

in WORK(1). No error message related to LWORK is issued

by XERBLA. Neither H nor Z are accessed.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

## subroutine slaqr4 (logical WANTT, logical WANTZ, integer N, integer ILO, integer IHI, real, dimension( ldh, * ) H, integer LDH, real, dimension( * ) WR, real, dimension( * ) WI, integer ILOZ, integer IHIZ, real, dimension( ldz, * ) Z, integer LDZ, real, dimension( * ) WORK, integer LWORK, integer INFO)¶

**SLAQR4** computes the eigenvalues of a Hessenberg matrix, and
optionally the matrices from the Schur decomposition.

**Purpose:**

SLAQR4 implements one level of recursion for SLAQR0.

It is a complete implementation of the small bulge multi-shift

QR algorithm. It may be called by SLAQR0 and, for large enough

deflation window size, it may be called by SLAQR3. This

subroutine is identical to SLAQR0 except that it calls SLAQR2

instead of SLAQR3.

SLAQR4 computes the eigenvalues of a Hessenberg matrix H

and, optionally, the matrices T and Z from the Schur decomposition

H = Z T Z**T, where T is an upper quasi-triangular matrix (the

Schur form), and Z is the orthogonal matrix of Schur vectors.

Optionally Z may be postmultiplied into an input orthogonal

matrix Q so that this routine can give the Schur factorization

of a matrix A which has been reduced to the Hessenberg form H

by the orthogonal matrix Q: A = Q*H*Q**T = (QZ)*T*(QZ)**T.

**Parameters**

*WANTT*

WANTT is LOGICAL

= .TRUE. : the full Schur form T is required;

= .FALSE.: only eigenvalues are required.

*WANTZ*

WANTZ is LOGICAL

= .TRUE. : the matrix of Schur vectors Z is required;

= .FALSE.: Schur vectors are not required.

*N*

N is INTEGER

The order of the matrix H. N >= 0.

*ILO*

ILO is INTEGER

*IHI*

IHI is INTEGER

It is assumed that H is already upper triangular in rows

and columns 1:ILO-1 and IHI+1:N and, if ILO > 1,

H(ILO,ILO-1) is zero. ILO and IHI are normally set by a

previous call to SGEBAL, and then passed to SGEHRD when the

matrix output by SGEBAL is reduced to Hessenberg form.

Otherwise, ILO and IHI should be set to 1 and N,

respectively. If N > 0, then 1 <= ILO <= IHI <= N.

If N = 0, then ILO = 1 and IHI = 0.

*H*

H is REAL array, dimension (LDH,N)

On entry, the upper Hessenberg matrix H.

On exit, if INFO = 0 and WANTT is .TRUE., then H contains

the upper quasi-triangular matrix T from the Schur

decomposition (the Schur form); 2-by-2 diagonal blocks

(corresponding to complex conjugate pairs of eigenvalues)

are returned in standard form, with H(i,i) = H(i+1,i+1)

and H(i+1,i)*H(i,i+1) < 0. If INFO = 0 and WANTT is

.FALSE., then the contents of H are unspecified on exit.

(The output value of H when INFO > 0 is given under the

description of INFO below.)

This subroutine may explicitly set H(i,j) = 0 for i > j and

j = 1, 2, ... ILO-1 or j = IHI+1, IHI+2, ... N.

*LDH*

LDH is INTEGER

The leading dimension of the array H. LDH >= max(1,N).

*WR*

WR is REAL array, dimension (IHI)

*WI*

WI is REAL array, dimension (IHI)

The real and imaginary parts, respectively, of the computed

eigenvalues of H(ILO:IHI,ILO:IHI) are stored in WR(ILO:IHI)

and WI(ILO:IHI). If two eigenvalues are computed as a

complex conjugate pair, they are stored in consecutive

elements of WR and WI, say the i-th and (i+1)th, with

WI(i) > 0 and WI(i+1) < 0. If WANTT is .TRUE., then

the eigenvalues are stored in the same order as on the

diagonal of the Schur form returned in H, with

WR(i) = H(i,i) and, if H(i:i+1,i:i+1) is a 2-by-2 diagonal

block, WI(i) = sqrt(-H(i+1,i)*H(i,i+1)) and

WI(i+1) = -WI(i).

*ILOZ*

ILOZ is INTEGER

*IHIZ*

IHIZ is INTEGER

Specify the rows of Z to which transformations must be

applied if WANTZ is .TRUE..

1 <= ILOZ <= ILO; IHI <= IHIZ <= N.

*Z*

Z is REAL array, dimension (LDZ,IHI)

If WANTZ is .FALSE., then Z is not referenced.

If WANTZ is .TRUE., then Z(ILO:IHI,ILOZ:IHIZ) is

replaced by Z(ILO:IHI,ILOZ:IHIZ)*U where U is the

orthogonal Schur factor of H(ILO:IHI,ILO:IHI).

(The output value of Z when INFO > 0 is given under

the description of INFO below.)

*LDZ*

LDZ is INTEGER

The leading dimension of the array Z. if WANTZ is .TRUE.

then LDZ >= MAX(1,IHIZ). Otherwise, LDZ >= 1.

*WORK*

WORK is REAL array, dimension LWORK

On exit, if LWORK = -1, WORK(1) returns an estimate of

the optimal value for LWORK.

*LWORK*

LWORK is INTEGER

The dimension of the array WORK. LWORK >= max(1,N)

is sufficient, but LWORK typically as large as 6*N may

be required for optimal performance. A workspace query

to determine the optimal workspace size is recommended.

If LWORK = -1, then SLAQR4 does a workspace query.

In this case, SLAQR4 checks the input parameters and

estimates the optimal workspace size for the given

values of N, ILO and IHI. The estimate is returned

in WORK(1). No error message related to LWORK is

issued by XERBLA. Neither H nor Z are accessed.

*INFO*

INFO is INTEGER

INFO is INTEGER

= 0: successful exit

> 0: if INFO = i, SLAQR4 failed to compute all of

the eigenvalues. Elements 1:ilo-1 and i+1:n of WR

and WI contain those eigenvalues which have been

successfully computed. (Failures are rare.)

If INFO > 0 and WANT is .FALSE., then on exit,

the remaining unconverged eigenvalues are the eigen-

values of the upper Hessenberg matrix rows and

columns ILO through INFO of the final, output

value of H.

If INFO > 0 and WANTT is .TRUE., then on exit

(*) (initial value of H)*U = U*(final value of H)

where U is a orthogonal matrix. The final

value of H is upper Hessenberg and triangular in

rows and columns INFO+1 through IHI.

If INFO > 0 and WANTZ is .TRUE., then on exit

(final value of Z(ILO:IHI,ILOZ:IHIZ)

= (initial value of Z(ILO:IHI,ILOZ:IHIZ)*U

where U is the orthogonal matrix in (*) (regard-

less of the value of WANTT.)

If INFO > 0 and WANTZ is .FALSE., then Z is not

accessed.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

**References:**

K. Braman, R. Byers and R. Mathias, The Multi-Shift QR

Algorithm Part I: Maintaining Well Focused Shifts, and Level 3

Performance, SIAM Journal of Matrix Analysis, volume 23, pages

929--947, 2002.

K. Braman, R. Byers and R. Mathias, The Multi-Shift QR Algorithm Part II:
Aggressive Early Deflation, SIAM Journal of Matrix Analysis, volume 23,
pages 948--973, 2002.

## subroutine slaqr5 (logical WANTT, logical WANTZ, integer KACC22, integer N, integer KTOP, integer KBOT, integer NSHFTS, real, dimension( * ) SR, real, dimension( * ) SI, real, dimension( ldh, * ) H, integer LDH, integer ILOZ, integer IHIZ, real, dimension( ldz, * ) Z, integer LDZ, real, dimension( ldv, * ) V, integer LDV, real, dimension( ldu, * ) U, integer LDU, integer NV, real, dimension( ldwv, * ) WV, integer LDWV, integer NH, real, dimension( ldwh, * ) WH, integer LDWH)¶

**SLAQR5** performs a single small-bulge multi-shift QR
sweep.

**Purpose:**

SLAQR5, called by SLAQR0, performs a

single small-bulge multi-shift QR sweep.

**Parameters**

*WANTT*

WANTT is LOGICAL

WANTT = .true. if the quasi-triangular Schur factor

is being computed. WANTT is set to .false. otherwise.

*WANTZ*

WANTZ is LOGICAL

WANTZ = .true. if the orthogonal Schur factor is being

computed. WANTZ is set to .false. otherwise.

*KACC22*

KACC22 is INTEGER with value 0, 1, or 2.

Specifies the computation mode of far-from-diagonal

orthogonal updates.

= 0: SLAQR5 does not accumulate reflections and does not

use matrix-matrix multiply to update far-from-diagonal

matrix entries.

= 1: SLAQR5 accumulates reflections and uses matrix-matrix

multiply to update the far-from-diagonal matrix entries.

= 2: SLAQR5 accumulates reflections, uses matrix-matrix

multiply to update the far-from-diagonal matrix entries,

and takes advantage of 2-by-2 block structure during

matrix multiplies.

*N*

N is INTEGER

N is the order of the Hessenberg matrix H upon which this

subroutine operates.

*KTOP*

KTOP is INTEGER

*KBOT*

KBOT is INTEGER

These are the first and last rows and columns of an

isolated diagonal block upon which the QR sweep is to be

applied. It is assumed without a check that

either KTOP = 1 or H(KTOP,KTOP-1) = 0

and

either KBOT = N or H(KBOT+1,KBOT) = 0.

*NSHFTS*

NSHFTS is INTEGER

NSHFTS gives the number of simultaneous shifts. NSHFTS

must be positive and even.

*SR*

SR is REAL array, dimension (NSHFTS)

*SI*

SI is REAL array, dimension (NSHFTS)

SR contains the real parts and SI contains the imaginary

parts of the NSHFTS shifts of origin that define the

multi-shift QR sweep. On output SR and SI may be

reordered.

*H*

H is REAL array, dimension (LDH,N)

On input H contains a Hessenberg matrix. On output a

multi-shift QR sweep with shifts SR(J)+i*SI(J) is applied

to the isolated diagonal block in rows and columns KTOP

through KBOT.

*LDH*

LDH is INTEGER

LDH is the leading dimension of H just as declared in the

calling procedure. LDH >= MAX(1,N).

*ILOZ*

ILOZ is INTEGER

*IHIZ*

IHIZ is INTEGER

Specify the rows of Z to which transformations must be

applied if WANTZ is .TRUE.. 1 <= ILOZ <= IHIZ <= N

*Z*

Z is REAL array, dimension (LDZ,IHIZ)

If WANTZ = .TRUE., then the QR Sweep orthogonal

similarity transformation is accumulated into

Z(ILOZ:IHIZ,ILOZ:IHIZ) from the right.

If WANTZ = .FALSE., then Z is unreferenced.

*LDZ*

LDZ is INTEGER

LDA is the leading dimension of Z just as declared in

the calling procedure. LDZ >= N.

*V*

V is REAL array, dimension (LDV,NSHFTS/2)

*LDV*

LDV is INTEGER

LDV is the leading dimension of V as declared in the

calling procedure. LDV >= 3.

*U*

U is REAL array, dimension (LDU,3*NSHFTS-3)

*LDU*

LDU is INTEGER

LDU is the leading dimension of U just as declared in the

in the calling subroutine. LDU >= 3*NSHFTS-3.

*NV*

NV is INTEGER

NV is the number of rows in WV agailable for workspace.

NV >= 1.

*WV*

WV is REAL array, dimension (LDWV,3*NSHFTS-3)

*LDWV*

LDWV is INTEGER

LDWV is the leading dimension of WV as declared in the

in the calling subroutine. LDWV >= NV.

*NH*

NH is INTEGER

NH is the number of columns in array WH available for

workspace. NH >= 1.

*WH*

WH is REAL array, dimension (LDWH,NH)

*LDWH*

LDWH is INTEGER

Leading dimension of WH just as declared in the

calling procedure. LDWH >= 3*NSHFTS-3.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

**References:**

## subroutine slaqsb (character UPLO, integer N, integer KD, real, dimension( ldab, * ) AB, integer LDAB, real, dimension( * ) S, real SCOND, real AMAX, character EQUED)¶

**SLAQSB** scales a symmetric/Hermitian band matrix, using
scaling factors computed by spbequ.

**Purpose:**

SLAQSB equilibrates a symmetric band matrix A using the scaling

factors in the vector S.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the upper or lower triangular part of the

symmetric matrix A is stored.

= 'U': Upper triangular

= 'L': Lower triangular

*N*

N is INTEGER

The order of the matrix A. N >= 0.

*KD*

KD is INTEGER

The number of super-diagonals of the matrix A if UPLO = 'U',

or the number of sub-diagonals if UPLO = 'L'. KD >= 0.

*AB*

AB is REAL array, dimension (LDAB,N)

On entry, the upper or lower triangle of the symmetric band

matrix A, stored in the first KD+1 rows of the array. The

j-th column of A is stored in the j-th column of the array AB

as follows:

if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;

if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).

On exit, if INFO = 0, the triangular factor U or L from the

Cholesky factorization A = U**T*U or A = L*L**T of the band

matrix A, in the same storage format as A.

*LDAB*

LDAB is INTEGER

The leading dimension of the array AB. LDAB >= KD+1.

*S*

S is REAL array, dimension (N)

The scale factors for A.

*SCOND*

SCOND is REAL

Ratio of the smallest S(i) to the largest S(i).

*AMAX*

AMAX is REAL

Absolute value of largest matrix entry.

*EQUED*

EQUED is CHARACTER*1

Specifies whether or not equilibration was done.

= 'N': No equilibration.

= 'Y': Equilibration was done, i.e., A has been replaced by

diag(S) * A * diag(S).

**Internal Parameters:**

THRESH is a threshold value used to decide if scaling should be done

based on the ratio of the scaling factors. If SCOND < THRESH,

scaling is done.

LARGE and SMALL are threshold values used to decide if scaling should

be done based on the absolute size of the largest matrix element.

If AMAX > LARGE or AMAX < SMALL, scaling is done.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slaqsp (character UPLO, integer N, real, dimension( * ) AP, real, dimension( * ) S, real SCOND, real AMAX, character EQUED)¶

**SLAQSP** scales a symmetric/Hermitian matrix in packed
storage, using scaling factors computed by sppequ.

**Purpose:**

SLAQSP equilibrates a symmetric matrix A using the scaling factors

in the vector S.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the upper or lower triangular part of the

symmetric matrix A is stored.

= 'U': Upper triangular

= 'L': Lower triangular

*N*

N is INTEGER

The order of the matrix A. N >= 0.

*AP*

AP is REAL array, dimension (N*(N+1)/2)

On entry, the upper or lower triangle of the symmetric matrix

A, packed columnwise in a linear array. The j-th column of A

is stored in the array AP as follows:

if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;

if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

On exit, the equilibrated matrix: diag(S) * A * diag(S), in

the same storage format as A.

*S*

S is REAL array, dimension (N)

The scale factors for A.

*SCOND*

SCOND is REAL

Ratio of the smallest S(i) to the largest S(i).

*AMAX*

AMAX is REAL

Absolute value of largest matrix entry.

*EQUED*

EQUED is CHARACTER*1

Specifies whether or not equilibration was done.

= 'N': No equilibration.

= 'Y': Equilibration was done, i.e., A has been replaced by

diag(S) * A * diag(S).

**Internal Parameters:**

THRESH is a threshold value used to decide if scaling should be done

based on the ratio of the scaling factors. If SCOND < THRESH,

scaling is done.

LARGE and SMALL are threshold values used to decide if scaling should

be done based on the absolute size of the largest matrix element.

If AMAX > LARGE or AMAX < SMALL, scaling is done.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slaqtr (logical LTRAN, logical LREAL, integer N, real, dimension( ldt, * ) T, integer LDT, real, dimension( * ) B, real W, real SCALE, real, dimension( * ) X, real, dimension( * ) WORK, integer INFO)¶

**SLAQTR** solves a real quasi-triangular system of equations,
or a complex quasi-triangular system of special form, in real
arithmetic.

**Purpose:**

SLAQTR solves the real quasi-triangular system

op(T)*p = scale*c, if LREAL = .TRUE.

or the complex quasi-triangular systems

op(T + iB)*(p+iq) = scale*(c+id), if LREAL = .FALSE.

in real arithmetic, where T is upper quasi-triangular.

If LREAL = .FALSE., then the first diagonal block of T must be

1 by 1, B is the specially structured matrix

B = [ b(1) b(2) ... b(n) ]

[ w ]

[ w ]

[ . ]

[ w ]

op(A) = A or A**T, A**T denotes the transpose of

matrix A.

On input, X = [ c ]. On output, X = [ p ].

[ d ] [ q ]

This subroutine is designed for the condition number estimation

in routine STRSNA.

**Parameters**

*LTRAN*

LTRAN is LOGICAL

On entry, LTRAN specifies the option of conjugate transpose:

= .FALSE., op(T+i*B) = T+i*B,

= .TRUE., op(T+i*B) = (T+i*B)**T.

*LREAL*

LREAL is LOGICAL

On entry, LREAL specifies the input matrix structure:

= .FALSE., the input is complex

= .TRUE., the input is real

*N*

N is INTEGER

On entry, N specifies the order of T+i*B. N >= 0.

*T*

T is REAL array, dimension (LDT,N)

On entry, T contains a matrix in Schur canonical form.

If LREAL = .FALSE., then the first diagonal block of T must

be 1 by 1.

*LDT*

LDT is INTEGER

The leading dimension of the matrix T. LDT >= max(1,N).

*B*

B is REAL array, dimension (N)

On entry, B contains the elements to form the matrix

B as described above.

If LREAL = .TRUE., B is not referenced.

*W*

W is REAL

On entry, W is the diagonal element of the matrix B.

If LREAL = .TRUE., W is not referenced.

*SCALE*

SCALE is REAL

On exit, SCALE is the scale factor.

*X*

X is REAL array, dimension (2*N)

On entry, X contains the right hand side of the system.

On exit, X is overwritten by the solution.

*WORK*

WORK is REAL array, dimension (N)

*INFO*

INFO is INTEGER

On exit, INFO is set to

0: successful exit.

1: the some diagonal 1 by 1 block has been perturbed by

a small number SMIN to keep nonsingularity.

2: the some diagonal 2 by 2 block has been perturbed by

a small number in SLALN2 to keep nonsingularity.

NOTE: In the interests of speed, this routine does not

check the inputs for errors.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slar1v (integer N, integer B1, integer BN, real LAMBDA, real, dimension( * ) D, real, dimension( * ) L, real, dimension( * ) LD, real, dimension( * ) LLD, real PIVMIN, real GAPTOL, real, dimension( * ) Z, logical WANTNC, integer NEGCNT, real ZTZ, real MINGMA, integer R, integer, dimension( * ) ISUPPZ, real NRMINV, real RESID, real RQCORR, real, dimension( * ) WORK)¶

**SLAR1V** computes the (scaled) r-th column of the inverse of
the submatrix in rows b1 through bn of the tridiagonal matrix LDLT -
λI.

**Purpose:**

SLAR1V computes the (scaled) r-th column of the inverse of

the sumbmatrix in rows B1 through BN of the tridiagonal matrix

L D L**T - sigma I. When sigma is close to an eigenvalue, the

computed vector is an accurate eigenvector. Usually, r corresponds

to the index where the eigenvector is largest in magnitude.

The following steps accomplish this computation :

(a) Stationary qd transform, L D L**T - sigma I = L(+) D(+) L(+)**T,

(b) Progressive qd transform, L D L**T - sigma I = U(-) D(-) U(-)**T,

(c) Computation of the diagonal elements of the inverse of

L D L**T - sigma I by combining the above transforms, and choosing

r as the index where the diagonal of the inverse is (one of the)

largest in magnitude.

(d) Computation of the (scaled) r-th column of the inverse using the

twisted factorization obtained by combining the top part of the

the stationary and the bottom part of the progressive transform.

**Parameters**

*N*

N is INTEGER

The order of the matrix L D L**T.

*B1*

B1 is INTEGER

First index of the submatrix of L D L**T.

*BN*

BN is INTEGER

Last index of the submatrix of L D L**T.

*LAMBDA*

LAMBDA is REAL

The shift. In order to compute an accurate eigenvector,

LAMBDA should be a good approximation to an eigenvalue

of L D L**T.

*L*

L is REAL array, dimension (N-1)

The (n-1) subdiagonal elements of the unit bidiagonal matrix

L, in elements 1 to N-1.

*D*

D is REAL array, dimension (N)

The n diagonal elements of the diagonal matrix D.

*LD*

LD is REAL array, dimension (N-1)

The n-1 elements L(i)*D(i).

*LLD*

LLD is REAL array, dimension (N-1)

The n-1 elements L(i)*L(i)*D(i).

*PIVMIN*

PIVMIN is REAL

The minimum pivot in the Sturm sequence.

*GAPTOL*

GAPTOL is REAL

Tolerance that indicates when eigenvector entries are negligible

w.r.t. their contribution to the residual.

*Z*

Z is REAL array, dimension (N)

On input, all entries of Z must be set to 0.

On output, Z contains the (scaled) r-th column of the

inverse. The scaling is such that Z(R) equals 1.

*WANTNC*

WANTNC is LOGICAL

Specifies whether NEGCNT has to be computed.

*NEGCNT*

NEGCNT is INTEGER

If WANTNC is .TRUE. then NEGCNT = the number of pivots < pivmin

in the matrix factorization L D L**T, and NEGCNT = -1 otherwise.

*ZTZ*

ZTZ is REAL

The square of the 2-norm of Z.

*MINGMA*

MINGMA is REAL

The reciprocal of the largest (in magnitude) diagonal

element of the inverse of L D L**T - sigma I.

*R*

R is INTEGER

The twist index for the twisted factorization used to

compute Z.

On input, 0 <= R <= N. If R is input as 0, R is set to

the index where (L D L**T - sigma I)^{-1} is largest

in magnitude. If 1 <= R <= N, R is unchanged.

On output, R contains the twist index used to compute Z.

Ideally, R designates the position of the maximum entry in the

eigenvector.

*ISUPPZ*

ISUPPZ is INTEGER array, dimension (2)

The support of the vector in Z, i.e., the vector Z is

nonzero only in elements ISUPPZ(1) through ISUPPZ( 2 ).

*NRMINV*

NRMINV is REAL

NRMINV = 1/SQRT( ZTZ )

*RESID*

RESID is REAL

The residual of the FP vector.

RESID = ABS( MINGMA )/SQRT( ZTZ )

*RQCORR*

RQCORR is REAL

The Rayleigh Quotient correction to LAMBDA.

RQCORR = MINGMA*TMP

*WORK*

WORK is REAL array, dimension (4*N)

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

Jim Demmel, University of California, Berkeley, USA

Inderjit Dhillon, University of Texas, Austin, USA

Osni Marques, LBNL/NERSC, USA

Christof Voemel, University of California, Berkeley, USA

## subroutine slar2v (integer N, real, dimension( * ) X, real, dimension( * ) Y, real, dimension( * ) Z, integer INCX, real, dimension( * ) C, real, dimension( * ) S, integer INCC)¶

**SLAR2V** applies a vector of plane rotations with real
cosines and real sines from both sides to a sequence of 2-by-2
symmetric/Hermitian matrices.

**Purpose:**

SLAR2V applies a vector of real plane rotations from both sides to

a sequence of 2-by-2 real symmetric matrices, defined by the elements

of the vectors x, y and z. For i = 1,2,...,n

( x(i) z(i) ) := ( c(i) s(i) ) ( x(i) z(i) ) ( c(i) -s(i) )

( z(i) y(i) ) ( -s(i) c(i) ) ( z(i) y(i) ) ( s(i) c(i) )

**Parameters**

*N*

N is INTEGER

The number of plane rotations to be applied.

*X*

X is REAL array,

dimension (1+(N-1)*INCX)

The vector x.

*Y*

Y is REAL array,

dimension (1+(N-1)*INCX)

The vector y.

*Z*

Z is REAL array,

dimension (1+(N-1)*INCX)

The vector z.

*INCX*

INCX is INTEGER

The increment between elements of X, Y and Z. INCX > 0.

*C*

C is REAL array, dimension (1+(N-1)*INCC)

The cosines of the plane rotations.

*S*

S is REAL array, dimension (1+(N-1)*INCC)

The sines of the plane rotations.

*INCC*

INCC is INTEGER

The increment between elements of C and S. INCC > 0.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slarf (character SIDE, integer M, integer N, real, dimension( * ) V, integer INCV, real TAU, real, dimension( ldc, * ) C, integer LDC, real, dimension( * ) WORK)¶

**SLARF** applies an elementary reflector to a general
rectangular matrix.

**Purpose:**

SLARF applies a real elementary reflector H to a real m by n matrix

C, from either the left or the right. H is represented in the form

H = I - tau * v * v**T

where tau is a real scalar and v is a real vector.

If tau = 0, then H is taken to be the unit matrix.

**Parameters**

*SIDE*

SIDE is CHARACTER*1

= 'L': form H * C

= 'R': form C * H

*M*

M is INTEGER

The number of rows of the matrix C.

*N*

N is INTEGER

The number of columns of the matrix C.

*V*

V is REAL array, dimension

(1 + (M-1)*abs(INCV)) if SIDE = 'L'

or (1 + (N-1)*abs(INCV)) if SIDE = 'R'

The vector v in the representation of H. V is not used if

TAU = 0.

*INCV*

INCV is INTEGER

The increment between elements of v. INCV <> 0.

*TAU*

TAU is REAL

The value tau in the representation of H.

*C*

C is REAL array, dimension (LDC,N)

On entry, the m by n matrix C.

On exit, C is overwritten by the matrix H * C if SIDE = 'L',

or C * H if SIDE = 'R'.

*LDC*

LDC is INTEGER

The leading dimension of the array C. LDC >= max(1,M).

*WORK*

WORK is REAL array, dimension

(N) if SIDE = 'L'

or (M) if SIDE = 'R'

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slarfb (character SIDE, character TRANS, character DIRECT, character STOREV, integer M, integer N, integer K, real, dimension( ldv, * ) V, integer LDV, real, dimension( ldt, * ) T, integer LDT, real, dimension( ldc, * ) C, integer LDC, real, dimension( ldwork, * ) WORK, integer LDWORK)¶

**SLARFB** applies a block reflector or its transpose to a
general rectangular matrix.

**Purpose:**

SLARFB applies a real block reflector H or its transpose H**T to a

real m by n matrix C, from either the left or the right.

**Parameters**

*SIDE*

SIDE is CHARACTER*1

= 'L': apply H or H**T from the Left

= 'R': apply H or H**T from the Right

*TRANS*

TRANS is CHARACTER*1

= 'N': apply H (No transpose)

= 'T': apply H**T (Transpose)

*DIRECT*

DIRECT is CHARACTER*1

Indicates how H is formed from a product of elementary

reflectors

= 'F': H = H(1) H(2) . . . H(k) (Forward)

= 'B': H = H(k) . . . H(2) H(1) (Backward)

*STOREV*

STOREV is CHARACTER*1

Indicates how the vectors which define the elementary

reflectors are stored:

= 'C': Columnwise

= 'R': Rowwise

*M*

M is INTEGER

The number of rows of the matrix C.

*N*

N is INTEGER

The number of columns of the matrix C.

*K*

K is INTEGER

The order of the matrix T (= the number of elementary

reflectors whose product defines the block reflector).

If SIDE = 'L', M >= K >= 0;

if SIDE = 'R', N >= K >= 0.

*V*

V is REAL array, dimension

(LDV,K) if STOREV = 'C'

(LDV,M) if STOREV = 'R' and SIDE = 'L'

(LDV,N) if STOREV = 'R' and SIDE = 'R'

The matrix V. See Further Details.

*LDV*

LDV is INTEGER

The leading dimension of the array V.

If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);

if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);

if STOREV = 'R', LDV >= K.

*T*

T is REAL array, dimension (LDT,K)

The triangular k by k matrix T in the representation of the

block reflector.

*LDT*

LDT is INTEGER

The leading dimension of the array T. LDT >= K.

*C*

C is REAL array, dimension (LDC,N)

On entry, the m by n matrix C.

On exit, C is overwritten by H*C or H**T*C or C*H or C*H**T.

*LDC*

LDC is INTEGER

The leading dimension of the array C. LDC >= max(1,M).

*WORK*

WORK is REAL array, dimension (LDWORK,K)

*LDWORK*

LDWORK is INTEGER

The leading dimension of the array WORK.

If SIDE = 'L', LDWORK >= max(1,N);

if SIDE = 'R', LDWORK >= max(1,M).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

The shape of the matrix V and the storage of the vectors which define

the H(i) is best illustrated by the following example with n = 5 and

k = 3. The elements equal to 1 are not stored; the corresponding

array elements are modified but restored on exit. The rest of the

array is not used.

DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R':

V = ( 1 ) V = ( 1 v1 v1 v1 v1 )

( v1 1 ) ( 1 v2 v2 v2 )

( v1 v2 1 ) ( 1 v3 v3 )

( v1 v2 v3 )

( v1 v2 v3 )

DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R':

V = ( v1 v2 v3 ) V = ( v1 v1 1 )

( v1 v2 v3 ) ( v2 v2 v2 1 )

( 1 v2 v3 ) ( v3 v3 v3 v3 1 )

( 1 v3 )

( 1 )

## subroutine slarfg (integer N, real ALPHA, real, dimension( * ) X, integer INCX, real TAU)¶

**SLARFG** generates an elementary reflector (Householder
matrix).

**Purpose:**

SLARFG generates a real elementary reflector H of order n, such

that

H * ( alpha ) = ( beta ), H**T * H = I.

( x ) ( 0 )

where alpha and beta are scalars, and x is an (n-1)-element real

vector. H is represented in the form

H = I - tau * ( 1 ) * ( 1 v**T ) ,

( v )

where tau is a real scalar and v is a real (n-1)-element

vector.

If the elements of x are all zero, then tau = 0 and H is taken to be

the unit matrix.

Otherwise 1 <= tau <= 2.

**Parameters**

*N*

N is INTEGER

The order of the elementary reflector.

*ALPHA*

ALPHA is REAL

On entry, the value alpha.

On exit, it is overwritten with the value beta.

*X*

X is REAL array, dimension

(1+(N-2)*abs(INCX))

On entry, the vector x.

On exit, it is overwritten with the vector v.

*INCX*

INCX is INTEGER

The increment between elements of X. INCX > 0.

*TAU*

TAU is REAL

The value tau.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slarfgp (integer N, real ALPHA, real, dimension( * ) X, integer INCX, real TAU)¶

**SLARFGP** generates an elementary reflector (Householder
matrix) with non-negative beta.

**Purpose:**

SLARFGP generates a real elementary reflector H of order n, such

that

H * ( alpha ) = ( beta ), H**T * H = I.

( x ) ( 0 )

where alpha and beta are scalars, beta is non-negative, and x is

an (n-1)-element real vector. H is represented in the form

H = I - tau * ( 1 ) * ( 1 v**T ) ,

( v )

where tau is a real scalar and v is a real (n-1)-element

vector.

If the elements of x are all zero, then tau = 0 and H is taken to be

the unit matrix.

**Parameters**

*N*

N is INTEGER

The order of the elementary reflector.

*ALPHA*

ALPHA is REAL

On entry, the value alpha.

On exit, it is overwritten with the value beta.

*X*

X is REAL array, dimension

(1+(N-2)*abs(INCX))

On entry, the vector x.

On exit, it is overwritten with the vector v.

*INCX*

INCX is INTEGER

The increment between elements of X. INCX > 0.

*TAU*

TAU is REAL

The value tau.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slarft (character DIRECT, character STOREV, integer N, integer K, real, dimension( ldv, * ) V, integer LDV, real, dimension( * ) TAU, real, dimension( ldt, * ) T, integer LDT)¶

**SLARFT** forms the triangular factor T of a block reflector H
= I - vtvH

**Purpose:**

SLARFT forms the triangular factor T of a real block reflector H

of order n, which is defined as a product of k elementary reflectors.

If DIRECT = 'F', H = H(1) H(2) . . . H(k) and T is upper triangular;

If DIRECT = 'B', H = H(k) . . . H(2) H(1) and T is lower triangular.

If STOREV = 'C', the vector which defines the elementary reflector

H(i) is stored in the i-th column of the array V, and

H = I - V * T * V**T

If STOREV = 'R', the vector which defines the elementary reflector

H(i) is stored in the i-th row of the array V, and

H = I - V**T * T * V

**Parameters**

*DIRECT*

DIRECT is CHARACTER*1

Specifies the order in which the elementary reflectors are

multiplied to form the block reflector:

= 'F': H = H(1) H(2) . . . H(k) (Forward)

= 'B': H = H(k) . . . H(2) H(1) (Backward)

*STOREV*

STOREV is CHARACTER*1

Specifies how the vectors which define the elementary

reflectors are stored (see also Further Details):

= 'C': columnwise

= 'R': rowwise

*N*

N is INTEGER

The order of the block reflector H. N >= 0.

*K*

K is INTEGER

The order of the triangular factor T (= the number of

elementary reflectors). K >= 1.

*V*

V is REAL array, dimension

(LDV,K) if STOREV = 'C'

(LDV,N) if STOREV = 'R'

The matrix V. See further details.

*LDV*

LDV is INTEGER

The leading dimension of the array V.

If STOREV = 'C', LDV >= max(1,N); if STOREV = 'R', LDV >= K.

*TAU*

TAU is REAL array, dimension (K)

TAU(i) must contain the scalar factor of the elementary

reflector H(i).

*T*

T is REAL array, dimension (LDT,K)

The k by k triangular factor T of the block reflector.

If DIRECT = 'F', T is upper triangular; if DIRECT = 'B', T is

lower triangular. The rest of the array is not used.

*LDT*

LDT is INTEGER

The leading dimension of the array T. LDT >= K.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

The shape of the matrix V and the storage of the vectors which define

the H(i) is best illustrated by the following example with n = 5 and

k = 3. The elements equal to 1 are not stored.

DIRECT = 'F' and STOREV = 'C': DIRECT = 'F' and STOREV = 'R':

V = ( 1 ) V = ( 1 v1 v1 v1 v1 )

( v1 1 ) ( 1 v2 v2 v2 )

( v1 v2 1 ) ( 1 v3 v3 )

( v1 v2 v3 )

( v1 v2 v3 )

DIRECT = 'B' and STOREV = 'C': DIRECT = 'B' and STOREV = 'R':

V = ( v1 v2 v3 ) V = ( v1 v1 1 )

( v1 v2 v3 ) ( v2 v2 v2 1 )

( 1 v2 v3 ) ( v3 v3 v3 v3 1 )

( 1 v3 )

( 1 )

## subroutine slarfx (character SIDE, integer M, integer N, real, dimension( * ) V, real TAU, real, dimension( ldc, * ) C, integer LDC, real, dimension( * ) WORK)¶

**SLARFX** applies an elementary reflector to a general
rectangular matrix, with loop unrolling when the reflector has order
≤ 10.

**Purpose:**

SLARFX applies a real elementary reflector H to a real m by n

matrix C, from either the left or the right. H is represented in the

form

H = I - tau * v * v**T

where tau is a real scalar and v is a real vector.

If tau = 0, then H is taken to be the unit matrix

This version uses inline code if H has order < 11.

**Parameters**

*SIDE*

SIDE is CHARACTER*1

= 'L': form H * C

= 'R': form C * H

*M*

M is INTEGER

The number of rows of the matrix C.

*N*

N is INTEGER

The number of columns of the matrix C.

*V*

V is REAL array, dimension (M) if SIDE = 'L'

or (N) if SIDE = 'R'

The vector v in the representation of H.

*TAU*

TAU is REAL

The value tau in the representation of H.

*C*

C is REAL array, dimension (LDC,N)

On entry, the m by n matrix C.

On exit, C is overwritten by the matrix H * C if SIDE = 'L',

or C * H if SIDE = 'R'.

*LDC*

LDC is INTEGER

The leading dimension of the array C. LDC >= (1,M).

*WORK*

WORK is REAL array, dimension

(N) if SIDE = 'L'

or (M) if SIDE = 'R'

WORK is not referenced if H has order < 11.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slarfy (character UPLO, integer N, real, dimension( * ) V, integer INCV, real TAU, real, dimension( ldc, * ) C, integer LDC, real, dimension( * ) WORK)¶

**SLARFY**

**Purpose:**

SLARFY applies an elementary reflector, or Householder matrix, H,

to an n x n symmetric matrix C, from both the left and the right.

H is represented in the form

H = I - tau * v * v'

where tau is a scalar and v is a vector.

If tau is zero, then H is taken to be the unit matrix.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the upper or lower triangular part of the

symmetric matrix C is stored.

= 'U': Upper triangle

= 'L': Lower triangle

*N*

N is INTEGER

The number of rows and columns of the matrix C. N >= 0.

*V*

V is REAL array, dimension

(1 + (N-1)*abs(INCV))

The vector v as described above.

*INCV*

INCV is INTEGER

The increment between successive elements of v. INCV must

not be zero.

*TAU*

TAU is REAL

The value tau as described above.

*C*

C is REAL array, dimension (LDC, N)

On entry, the matrix C.

On exit, C is overwritten by H * C * H'.

*LDC*

LDC is INTEGER

The leading dimension of the array C. LDC >= max( 1, N ).

*WORK*

WORK is REAL array, dimension (N)

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slargv (integer N, real, dimension( * ) X, integer INCX, real, dimension( * ) Y, integer INCY, real, dimension( * ) C, integer INCC)¶

**SLARGV** generates a vector of plane rotations with real
cosines and real sines.

**Purpose:**

SLARGV generates a vector of real plane rotations, determined by

elements of the real vectors x and y. For i = 1,2,...,n

( c(i) s(i) ) ( x(i) ) = ( a(i) )

( -s(i) c(i) ) ( y(i) ) = ( 0 )

**Parameters**

*N*

N is INTEGER

The number of plane rotations to be generated.

*X*

X is REAL array,

dimension (1+(N-1)*INCX)

On entry, the vector x.

On exit, x(i) is overwritten by a(i), for i = 1,...,n.

*INCX*

INCX is INTEGER

The increment between elements of X. INCX > 0.

*Y*

Y is REAL array,

dimension (1+(N-1)*INCY)

On entry, the vector y.

On exit, the sines of the plane rotations.

*INCY*

INCY is INTEGER

The increment between elements of Y. INCY > 0.

*C*

C is REAL array, dimension (1+(N-1)*INCC)

The cosines of the plane rotations.

*INCC*

INCC is INTEGER

The increment between elements of C. INCC > 0.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slarrv (integer N, real VL, real VU, real, dimension( * ) D, real, dimension( * ) L, real PIVMIN, integer, dimension( * ) ISPLIT, integer M, integer DOL, integer DOU, real MINRGP, real RTOL1, real RTOL2, real, dimension( * ) W, real, dimension( * ) WERR, real, dimension( * ) WGAP, integer, dimension( * ) IBLOCK, integer, dimension( * ) INDEXW, real, dimension( * ) GERS, real, dimension( ldz, * ) Z, integer LDZ, integer, dimension( * ) ISUPPZ, real, dimension( * ) WORK, integer, dimension( * ) IWORK, integer INFO)¶

**SLARRV** computes the eigenvectors of the tridiagonal matrix
T = L D LT given L, D and the eigenvalues of L D LT.

**Purpose:**

SLARRV computes the eigenvectors of the tridiagonal matrix

T = L D L**T given L, D and APPROXIMATIONS to the eigenvalues of L D L**T.

The input eigenvalues should have been computed by SLARRE.

**Parameters**

*N*

N is INTEGER

The order of the matrix. N >= 0.

*VL*

VL is REAL

Lower bound of the interval that contains the desired

eigenvalues. VL < VU. Needed to compute gaps on the left or right

end of the extremal eigenvalues in the desired RANGE.

*VU*

VU is REAL

Upper bound of the interval that contains the desired

eigenvalues. VL < VU.

Note: VU is currently not used by this implementation of SLARRV, VU is

passed to SLARRV because it could be used compute gaps on the right end

of the extremal eigenvalues. However, with not much initial accuracy in

LAMBDA and VU, the formula can lead to an overestimation of the right gap

and thus to inadequately early RQI 'convergence'. This is currently

prevented this by forcing a small right gap. And so it turns out that VU

is currently not used by this implementation of SLARRV.

*D*

D is REAL array, dimension (N)

On entry, the N diagonal elements of the diagonal matrix D.

On exit, D may be overwritten.

*L*

L is REAL array, dimension (N)

On entry, the (N-1) subdiagonal elements of the unit

bidiagonal matrix L are in elements 1 to N-1 of L

(if the matrix is not split.) At the end of each block

is stored the corresponding shift as given by SLARRE.

On exit, L is overwritten.

*PIVMIN*

PIVMIN is REAL

The minimum pivot allowed in the Sturm sequence.

*ISPLIT*

ISPLIT is INTEGER array, dimension (N)

The splitting points, at which T breaks up into blocks.

The first block consists of rows/columns 1 to

ISPLIT( 1 ), the second of rows/columns ISPLIT( 1 )+1

through ISPLIT( 2 ), etc.

*M*

M is INTEGER

The total number of input eigenvalues. 0 <= M <= N.

*DOL*

DOL is INTEGER

*DOU*

DOU is INTEGER

If the user wants to compute only selected eigenvectors from all

the eigenvalues supplied, he can specify an index range DOL:DOU.

Or else the setting DOL=1, DOU=M should be applied.

Note that DOL and DOU refer to the order in which the eigenvalues

are stored in W.

If the user wants to compute only selected eigenpairs, then

the columns DOL-1 to DOU+1 of the eigenvector space Z contain the

computed eigenvectors. All other columns of Z are set to zero.

*MINRGP*

MINRGP is REAL

*RTOL1*

RTOL1 is REAL

*RTOL2*

RTOL2 is REAL

Parameters for bisection.

An interval [LEFT,RIGHT] has converged if

RIGHT-LEFT < MAX( RTOL1*GAP, RTOL2*MAX(|LEFT|,|RIGHT|) )

*W*

W is REAL array, dimension (N)

The first M elements of W contain the APPROXIMATE eigenvalues for

which eigenvectors are to be computed. The eigenvalues

should be grouped by split-off block and ordered from

smallest to largest within the block ( The output array

W from SLARRE is expected here ). Furthermore, they are with

respect to the shift of the corresponding root representation

for their block. On exit, W holds the eigenvalues of the

UNshifted matrix.

*WERR*

WERR is REAL array, dimension (N)

The first M elements contain the semiwidth of the uncertainty

interval of the corresponding eigenvalue in W

*WGAP*

WGAP is REAL array, dimension (N)

The separation from the right neighbor eigenvalue in W.

*IBLOCK*

IBLOCK is INTEGER array, dimension (N)

The indices of the blocks (submatrices) associated with the

corresponding eigenvalues in W; IBLOCK(i)=1 if eigenvalue

W(i) belongs to the first block from the top, =2 if W(i)

belongs to the second block, etc.

*INDEXW*

INDEXW is INTEGER array, dimension (N)

The indices of the eigenvalues within each block (submatrix);

for example, INDEXW(i)= 10 and IBLOCK(i)=2 imply that the

i-th eigenvalue W(i) is the 10-th eigenvalue in the second block.

*GERS*

GERS is REAL array, dimension (2*N)

The N Gerschgorin intervals (the i-th Gerschgorin interval

is (GERS(2*i-1), GERS(2*i)). The Gerschgorin intervals should

be computed from the original UNshifted matrix.

*Z*

Z is REAL array, dimension (LDZ, max(1,M) )

If INFO = 0, the first M columns of Z contain the

orthonormal eigenvectors of the matrix T

corresponding to the input eigenvalues, with the i-th

column of Z holding the eigenvector associated with W(i).

Note: the user must ensure that at least max(1,M) columns are

supplied in the array Z.

*LDZ*

LDZ is INTEGER

The leading dimension of the array Z. LDZ >= 1, and if

JOBZ = 'V', LDZ >= max(1,N).

*ISUPPZ*

ISUPPZ is INTEGER array, dimension ( 2*max(1,M) )

The support of the eigenvectors in Z, i.e., the indices

indicating the nonzero elements in Z. The I-th eigenvector

is nonzero only in elements ISUPPZ( 2*I-1 ) through

ISUPPZ( 2*I ).

*WORK*

WORK is REAL array, dimension (12*N)

*IWORK*

IWORK is INTEGER array, dimension (7*N)

*INFO*

INFO is INTEGER

= 0: successful exit

> 0: A problem occurred in SLARRV.

< 0: One of the called subroutines signaled an internal problem.

Needs inspection of the corresponding parameter IINFO

for further information.

=-1: Problem in SLARRB when refining a child's eigenvalues.

=-2: Problem in SLARRF when computing the RRR of a child.

When a child is inside a tight cluster, it can be difficult

to find an RRR. A partial remedy from the user's point of

view is to make the parameter MINRGP smaller and recompile.

However, as the orthogonality of the computed vectors is

proportional to 1/MINRGP, the user should be aware that

he might be trading in precision when he decreases MINRGP.

=-3: Problem in SLARRB when refining a single eigenvalue

after the Rayleigh correction was rejected.

= 5: The Rayleigh Quotient Iteration failed to converge to

full accuracy in MAXITR steps.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Contributors:**

Jim Demmel, University of California, Berkeley, USA

Inderjit Dhillon, University of Texas, Austin, USA

Osni Marques, LBNL/NERSC, USA

Christof Voemel, University of California, Berkeley, USA

## subroutine slartv (integer N, real, dimension( * ) X, integer INCX, real, dimension( * ) Y, integer INCY, real, dimension( * ) C, real, dimension( * ) S, integer INCC)¶

**SLARTV** applies a vector of plane rotations with real
cosines and real sines to the elements of a pair of vectors.

**Purpose:**

SLARTV applies a vector of real plane rotations to elements of the

real vectors x and y. For i = 1,2,...,n

( x(i) ) := ( c(i) s(i) ) ( x(i) )

( y(i) ) ( -s(i) c(i) ) ( y(i) )

**Parameters**

*N*

N is INTEGER

The number of plane rotations to be applied.

*X*

X is REAL array,

dimension (1+(N-1)*INCX)

The vector x.

*INCX*

INCX is INTEGER

The increment between elements of X. INCX > 0.

*Y*

Y is REAL array,

dimension (1+(N-1)*INCY)

The vector y.

*INCY*

INCY is INTEGER

The increment between elements of Y. INCY > 0.

*C*

C is REAL array, dimension (1+(N-1)*INCC)

The cosines of the plane rotations.

*S*

S is REAL array, dimension (1+(N-1)*INCC)

The sines of the plane rotations.

*INCC*

INCC is INTEGER

The increment between elements of C and S. INCC > 0.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slaswp (integer N, real, dimension( lda, * ) A, integer LDA, integer K1, integer K2, integer, dimension( * ) IPIV, integer INCX)¶

**SLASWP** performs a series of row interchanges on a general
rectangular matrix.

**Purpose:**

SLASWP performs a series of row interchanges on the matrix A.

One row interchange is initiated for each of rows K1 through K2 of A.

**Parameters**

*N*

N is INTEGER

The number of columns of the matrix A.

*A*

A is REAL array, dimension (LDA,N)

On entry, the matrix of column dimension N to which the row

interchanges will be applied.

On exit, the permuted matrix.

*LDA*

LDA is INTEGER

The leading dimension of the array A.

*K1*

K1 is INTEGER

The first element of IPIV for which a row interchange will

be done.

*K2*

K2 is INTEGER

(K2-K1+1) is the number of elements of IPIV for which a row

interchange will be done.

*IPIV*

IPIV is INTEGER array, dimension (K1+(K2-K1)*abs(INCX))

The vector of pivot indices. Only the elements in positions

K1 through K1+(K2-K1)*abs(INCX) of IPIV are accessed.

IPIV(K1+(K-K1)*abs(INCX)) = L implies rows K and L are to be

interchanged.

*INCX*

INCX is INTEGER

The increment between successive values of IPIV. If INCX

is negative, the pivots are applied in reverse order.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

Modified by

R. C. Whaley, Computer Science Dept., Univ. of Tenn., Knoxville, USA

## subroutine slatbs (character UPLO, character TRANS, character DIAG, character NORMIN, integer N, integer KD, real, dimension( ldab, * ) AB, integer LDAB, real, dimension( * ) X, real SCALE, real, dimension( * ) CNORM, integer INFO)¶

**SLATBS** solves a triangular banded system of equations.

**Purpose:**

SLATBS solves one of the triangular systems

A *x = s*b or A**T*x = s*b

with scaling to prevent overflow, where A is an upper or lower

triangular band matrix. Here A**T denotes the transpose of A, x and b

are n-element vectors, and s is a scaling factor, usually less than

or equal to 1, chosen so that the components of x will be less than

the overflow threshold. If the unscaled problem will not cause

overflow, the Level 2 BLAS routine STBSV is called. If the matrix A

is singular (A(j,j) = 0 for some j), then s is set to 0 and a

non-trivial solution to A*x = 0 is returned.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the matrix A is upper or lower triangular.

= 'U': Upper triangular

= 'L': Lower triangular

*TRANS*

TRANS is CHARACTER*1

Specifies the operation applied to A.

= 'N': Solve A * x = s*b (No transpose)

= 'T': Solve A**T* x = s*b (Transpose)

= 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)

*DIAG*

DIAG is CHARACTER*1

Specifies whether or not the matrix A is unit triangular.

= 'N': Non-unit triangular

= 'U': Unit triangular

*NORMIN*

NORMIN is CHARACTER*1

Specifies whether CNORM has been set or not.

= 'Y': CNORM contains the column norms on entry

= 'N': CNORM is not set on entry. On exit, the norms will

be computed and stored in CNORM.

*N*

N is INTEGER

The order of the matrix A. N >= 0.

*KD*

KD is INTEGER

The number of subdiagonals or superdiagonals in the

triangular matrix A. KD >= 0.

*AB*

AB is REAL array, dimension (LDAB,N)

The upper or lower triangular band matrix A, stored in the

first KD+1 rows of the array. The j-th column of A is stored

in the j-th column of the array AB as follows:

if UPLO = 'U', AB(kd+1+i-j,j) = A(i,j) for max(1,j-kd)<=i<=j;

if UPLO = 'L', AB(1+i-j,j) = A(i,j) for j<=i<=min(n,j+kd).

*LDAB*

LDAB is INTEGER

The leading dimension of the array AB. LDAB >= KD+1.

*X*

X is REAL array, dimension (N)

On entry, the right hand side b of the triangular system.

On exit, X is overwritten by the solution vector x.

*SCALE*

SCALE is REAL

The scaling factor s for the triangular system

A * x = s*b or A**T* x = s*b.

If SCALE = 0, the matrix A is singular or badly scaled, and

the vector x is an exact or approximate solution to A*x = 0.

*CNORM*

CNORM is REAL array, dimension (N)

If NORMIN = 'Y', CNORM is an input argument and CNORM(j)

contains the norm of the off-diagonal part of the j-th column

of A. If TRANS = 'N', CNORM(j) must be greater than or equal

to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)

must be greater than or equal to the 1-norm.

If NORMIN = 'N', CNORM is an output argument and CNORM(j)

returns the 1-norm of the offdiagonal part of the j-th column

of A.

*INFO*

INFO is INTEGER

= 0: successful exit

< 0: if INFO = -k, the k-th argument had an illegal value

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

A rough bound on x is computed; if that is less than overflow, STBSV

is called, otherwise, specific code is used which checks for possible

overflow or divide-by-zero at every operation.

A columnwise scheme is used for solving A*x = b. The basic algorithm

if A is lower triangular is

x[1:n] := b[1:n]

for j = 1, ..., n

x(j) := x(j) / A(j,j)

x[j+1:n] := x[j+1:n] - x(j) * A[j+1:n,j]

end

Define bounds on the components of x after j iterations of the loop:

M(j) = bound on x[1:j]

G(j) = bound on x[j+1:n]

Initially, let M(0) = 0 and G(0) = max{x(i), i=1,...,n}.

Then for iteration j+1 we have

M(j+1) <= G(j) / | A(j+1,j+1) |

G(j+1) <= G(j) + M(j+1) * | A[j+2:n,j+1] |

<= G(j) ( 1 + CNORM(j+1) / | A(j+1,j+1) | )

where CNORM(j+1) is greater than or equal to the infinity-norm of

column j+1 of A, not counting the diagonal. Hence

G(j) <= G(0) product ( 1 + CNORM(i) / | A(i,i) | )

1<=i<=j

and

|x(j)| <= ( G(0) / |A(j,j)| ) product ( 1 + CNORM(i) / |A(i,i)| )

1<=i< j

Since |x(j)| <= M(j), we use the Level 2 BLAS routine STBSV if the

reciprocal of the largest M(j), j=1,..,n, is larger than

max(underflow, 1/overflow).

The bound on x(j) is also used to determine when a step in the

columnwise method can be performed without fear of overflow. If

the computed bound is greater than a large constant, x is scaled to

prevent overflow, but if the bound overflows, x is set to 0, x(j) to

1, and scale to 0, and a non-trivial solution to A*x = 0 is found.

Similarly, a row-wise scheme is used to solve A**T*x = b. The basic

algorithm for A upper triangular is

for j = 1, ..., n

x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)

end

We simultaneously compute two bounds

G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j

M(j) = bound on x(i), 1<=i<=j

The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we

add the constraint G(j) >= G(j-1) and M(j) >= M(j-1) for j >= 1.

Then the bound on x(j) is

M(j) <= M(j-1) * ( 1 + CNORM(j) ) / | A(j,j) |

<= M(0) * product ( ( 1 + CNORM(i) ) / |A(i,i)| )

1<=i<=j

and we can safely call STBSV if 1/M(n) and 1/G(n) are both greater

than max(underflow, 1/overflow).

## subroutine slatdf (integer IJOB, integer N, real, dimension( ldz, * ) Z, integer LDZ, real, dimension( * ) RHS, real RDSUM, real RDSCAL, integer, dimension( * ) IPIV, integer, dimension( * ) JPIV)¶

**SLATDF** uses the LU factorization of the n-by-n matrix
computed by sgetc2 and computes a contribution to the reciprocal
Dif-estimate.

**Purpose:**

SLATDF uses the LU factorization of the n-by-n matrix Z computed by

SGETC2 and computes a contribution to the reciprocal Dif-estimate

by solving Z * x = b for x, and choosing the r.h.s. b such that

the norm of x is as large as possible. On entry RHS = b holds the

contribution from earlier solved sub-systems, and on return RHS = x.

The factorization of Z returned by SGETC2 has the form Z = P*L*U*Q,

where P and Q are permutation matrices. L is lower triangular with

unit diagonal elements and U is upper triangular.

**Parameters**

*IJOB*

IJOB is INTEGER

IJOB = 2: First compute an approximative null-vector e

of Z using SGECON, e is normalized and solve for

Zx = +-e - f with the sign giving the greater value

of 2-norm(x). About 5 times as expensive as Default.

IJOB .ne. 2: Local look ahead strategy where all entries of

the r.h.s. b is chosen as either +1 or -1 (Default).

*N*

N is INTEGER

The number of columns of the matrix Z.

*Z*

Z is REAL array, dimension (LDZ, N)

On entry, the LU part of the factorization of the n-by-n

matrix Z computed by SGETC2: Z = P * L * U * Q

*LDZ*

LDZ is INTEGER

The leading dimension of the array Z. LDA >= max(1, N).

*RHS*

RHS is REAL array, dimension N.

On entry, RHS contains contributions from other subsystems.

On exit, RHS contains the solution of the subsystem with

entries according to the value of IJOB (see above).

*RDSUM*

RDSUM is REAL

On entry, the sum of squares of computed contributions to

the Dif-estimate under computation by STGSYL, where the

scaling factor RDSCAL (see below) has been factored out.

On exit, the corresponding sum of squares updated with the

contributions from the current sub-system.

If TRANS = 'T' RDSUM is not touched.

NOTE: RDSUM only makes sense when STGSY2 is called by STGSYL.

*RDSCAL*

RDSCAL is REAL

On entry, scaling factor used to prevent overflow in RDSUM.

On exit, RDSCAL is updated w.r.t. the current contributions

in RDSUM.

If TRANS = 'T', RDSCAL is not touched.

NOTE: RDSCAL only makes sense when STGSY2 is called by

STGSYL.

*IPIV*

IPIV is INTEGER array, dimension (N).

The pivot indices; for 1 <= i <= N, row i of the

matrix has been interchanged with row IPIV(i).

*JPIV*

JPIV is INTEGER array, dimension (N).

The pivot indices; for 1 <= j <= N, column j of the

matrix has been interchanged with column JPIV(j).

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

**Contributors:**

**References:**

[1] Bo Kagstrom and Lars Westin,

Generalized Schur Methods with Condition Estimators for

Solving the Generalized Sylvester Equation, IEEE Transactions

on Automatic Control, Vol. 34, No. 7, July 1989, pp 745-751.

[2] Peter Poromaa,

On Efficient and Robust Estimators for the Separation

between two Regular Matrix Pairs with Applications in

Condition Estimation. Report IMINF-95.05, Departement of

Computing Science, Umea University, S-901 87 Umea, Sweden, 1995.

## subroutine slatps (character UPLO, character TRANS, character DIAG, character NORMIN, integer N, real, dimension( * ) AP, real, dimension( * ) X, real SCALE, real, dimension( * ) CNORM, integer INFO)¶

**SLATPS** solves a triangular system of equations with the
matrix held in packed storage.

**Purpose:**

SLATPS solves one of the triangular systems

A *x = s*b or A**T*x = s*b

with scaling to prevent overflow, where A is an upper or lower

triangular matrix stored in packed form. Here A**T denotes the

transpose of A, x and b are n-element vectors, and s is a scaling

factor, usually less than or equal to 1, chosen so that the

components of x will be less than the overflow threshold. If the

unscaled problem will not cause overflow, the Level 2 BLAS routine

STPSV is called. If the matrix A is singular (A(j,j) = 0 for some j),

then s is set to 0 and a non-trivial solution to A*x = 0 is returned.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the matrix A is upper or lower triangular.

= 'U': Upper triangular

= 'L': Lower triangular

*TRANS*

TRANS is CHARACTER*1

Specifies the operation applied to A.

= 'N': Solve A * x = s*b (No transpose)

= 'T': Solve A**T* x = s*b (Transpose)

= 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)

*DIAG*

DIAG is CHARACTER*1

Specifies whether or not the matrix A is unit triangular.

= 'N': Non-unit triangular

= 'U': Unit triangular

*NORMIN*

NORMIN is CHARACTER*1

Specifies whether CNORM has been set or not.

= 'Y': CNORM contains the column norms on entry

= 'N': CNORM is not set on entry. On exit, the norms will

be computed and stored in CNORM.

*N*

N is INTEGER

The order of the matrix A. N >= 0.

*AP*

AP is REAL array, dimension (N*(N+1)/2)

The upper or lower triangular matrix A, packed columnwise in

a linear array. The j-th column of A is stored in the array

AP as follows:

if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;

if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.

*X*

X is REAL array, dimension (N)

On entry, the right hand side b of the triangular system.

On exit, X is overwritten by the solution vector x.

*SCALE*

SCALE is REAL

The scaling factor s for the triangular system

A * x = s*b or A**T* x = s*b.

If SCALE = 0, the matrix A is singular or badly scaled, and

the vector x is an exact or approximate solution to A*x = 0.

*CNORM*

CNORM is REAL array, dimension (N)

If NORMIN = 'Y', CNORM is an input argument and CNORM(j)

contains the norm of the off-diagonal part of the j-th column

of A. If TRANS = 'N', CNORM(j) must be greater than or equal

to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)

must be greater than or equal to the 1-norm.

If NORMIN = 'N', CNORM is an output argument and CNORM(j)

returns the 1-norm of the offdiagonal part of the j-th column

of A.

*INFO*

INFO is INTEGER

= 0: successful exit

< 0: if INFO = -k, the k-th argument had an illegal value

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

A rough bound on x is computed; if that is less than overflow, STPSV

is called, otherwise, specific code is used which checks for possible

overflow or divide-by-zero at every operation.

A columnwise scheme is used for solving A*x = b. The basic algorithm

if A is lower triangular is

x[1:n] := b[1:n]

for j = 1, ..., n

x(j) := x(j) / A(j,j)

x[j+1:n] := x[j+1:n] - x(j) * A[j+1:n,j]

end

Define bounds on the components of x after j iterations of the loop:

M(j) = bound on x[1:j]

G(j) = bound on x[j+1:n]

Initially, let M(0) = 0 and G(0) = max{x(i), i=1,...,n}.

Then for iteration j+1 we have

M(j+1) <= G(j) / | A(j+1,j+1) |

G(j+1) <= G(j) + M(j+1) * | A[j+2:n,j+1] |

<= G(j) ( 1 + CNORM(j+1) / | A(j+1,j+1) | )

where CNORM(j+1) is greater than or equal to the infinity-norm of

column j+1 of A, not counting the diagonal. Hence

G(j) <= G(0) product ( 1 + CNORM(i) / | A(i,i) | )

1<=i<=j

and

|x(j)| <= ( G(0) / |A(j,j)| ) product ( 1 + CNORM(i) / |A(i,i)| )

1<=i< j

Since |x(j)| <= M(j), we use the Level 2 BLAS routine STPSV if the

reciprocal of the largest M(j), j=1,..,n, is larger than

max(underflow, 1/overflow).

The bound on x(j) is also used to determine when a step in the

columnwise method can be performed without fear of overflow. If

the computed bound is greater than a large constant, x is scaled to

prevent overflow, but if the bound overflows, x is set to 0, x(j) to

1, and scale to 0, and a non-trivial solution to A*x = 0 is found.

Similarly, a row-wise scheme is used to solve A**T*x = b. The basic

algorithm for A upper triangular is

for j = 1, ..., n

x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)

end

We simultaneously compute two bounds

G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j

M(j) = bound on x(i), 1<=i<=j

The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we

add the constraint G(j) >= G(j-1) and M(j) >= M(j-1) for j >= 1.

Then the bound on x(j) is

M(j) <= M(j-1) * ( 1 + CNORM(j) ) / | A(j,j) |

<= M(0) * product ( ( 1 + CNORM(i) ) / |A(i,i)| )

1<=i<=j

and we can safely call STPSV if 1/M(n) and 1/G(n) are both greater

than max(underflow, 1/overflow).

## subroutine slatrs (character UPLO, character TRANS, character DIAG, character NORMIN, integer N, real, dimension( lda, * ) A, integer LDA, real, dimension( * ) X, real SCALE, real, dimension( * ) CNORM, integer INFO)¶

**SLATRS** solves a triangular system of equations with the
scale factor set to prevent overflow.

**Purpose:**

SLATRS solves one of the triangular systems

A *x = s*b or A**T*x = s*b

with scaling to prevent overflow. Here A is an upper or lower

triangular matrix, A**T denotes the transpose of A, x and b are

n-element vectors, and s is a scaling factor, usually less than

or equal to 1, chosen so that the components of x will be less than

the overflow threshold. If the unscaled problem will not cause

overflow, the Level 2 BLAS routine STRSV is called. If the matrix A

is singular (A(j,j) = 0 for some j), then s is set to 0 and a

non-trivial solution to A*x = 0 is returned.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the matrix A is upper or lower triangular.

= 'U': Upper triangular

= 'L': Lower triangular

*TRANS*

TRANS is CHARACTER*1

Specifies the operation applied to A.

= 'N': Solve A * x = s*b (No transpose)

= 'T': Solve A**T* x = s*b (Transpose)

= 'C': Solve A**T* x = s*b (Conjugate transpose = Transpose)

*DIAG*

DIAG is CHARACTER*1

Specifies whether or not the matrix A is unit triangular.

= 'N': Non-unit triangular

= 'U': Unit triangular

*NORMIN*

NORMIN is CHARACTER*1

Specifies whether CNORM has been set or not.

= 'Y': CNORM contains the column norms on entry

= 'N': CNORM is not set on entry. On exit, the norms will

be computed and stored in CNORM.

*N*

N is INTEGER

The order of the matrix A. N >= 0.

*A*

A is REAL array, dimension (LDA,N)

The triangular matrix A. If UPLO = 'U', the leading n by n

upper triangular part of the array A contains the upper

triangular matrix, and the strictly lower triangular part of

A is not referenced. If UPLO = 'L', the leading n by n lower

triangular part of the array A contains the lower triangular

matrix, and the strictly upper triangular part of A is not

referenced. If DIAG = 'U', the diagonal elements of A are

also not referenced and are assumed to be 1.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max (1,N).

*X*

X is REAL array, dimension (N)

On entry, the right hand side b of the triangular system.

On exit, X is overwritten by the solution vector x.

*SCALE*

SCALE is REAL

The scaling factor s for the triangular system

A * x = s*b or A**T* x = s*b.

If SCALE = 0, the matrix A is singular or badly scaled, and

the vector x is an exact or approximate solution to A*x = 0.

*CNORM*

CNORM is REAL array, dimension (N)

If NORMIN = 'Y', CNORM is an input argument and CNORM(j)

contains the norm of the off-diagonal part of the j-th column

of A. If TRANS = 'N', CNORM(j) must be greater than or equal

to the infinity-norm, and if TRANS = 'T' or 'C', CNORM(j)

must be greater than or equal to the 1-norm.

If NORMIN = 'N', CNORM is an output argument and CNORM(j)

returns the 1-norm of the offdiagonal part of the j-th column

of A.

*INFO*

INFO is INTEGER

= 0: successful exit

< 0: if INFO = -k, the k-th argument had an illegal value

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

A rough bound on x is computed; if that is less than overflow, STRSV

is called, otherwise, specific code is used which checks for possible

overflow or divide-by-zero at every operation.

A columnwise scheme is used for solving A*x = b. The basic algorithm

if A is lower triangular is

x[1:n] := b[1:n]

for j = 1, ..., n

x(j) := x(j) / A(j,j)

x[j+1:n] := x[j+1:n] - x(j) * A[j+1:n,j]

end

Define bounds on the components of x after j iterations of the loop:

M(j) = bound on x[1:j]

G(j) = bound on x[j+1:n]

Initially, let M(0) = 0 and G(0) = max{x(i), i=1,...,n}.

Then for iteration j+1 we have

M(j+1) <= G(j) / | A(j+1,j+1) |

G(j+1) <= G(j) + M(j+1) * | A[j+2:n,j+1] |

<= G(j) ( 1 + CNORM(j+1) / | A(j+1,j+1) | )

where CNORM(j+1) is greater than or equal to the infinity-norm of

column j+1 of A, not counting the diagonal. Hence

G(j) <= G(0) product ( 1 + CNORM(i) / | A(i,i) | )

1<=i<=j

and

|x(j)| <= ( G(0) / |A(j,j)| ) product ( 1 + CNORM(i) / |A(i,i)| )

1<=i< j

Since |x(j)| <= M(j), we use the Level 2 BLAS routine STRSV if the

reciprocal of the largest M(j), j=1,..,n, is larger than

max(underflow, 1/overflow).

The bound on x(j) is also used to determine when a step in the

columnwise method can be performed without fear of overflow. If

the computed bound is greater than a large constant, x is scaled to

prevent overflow, but if the bound overflows, x is set to 0, x(j) to

1, and scale to 0, and a non-trivial solution to A*x = 0 is found.

Similarly, a row-wise scheme is used to solve A**T*x = b. The basic

algorithm for A upper triangular is

for j = 1, ..., n

x(j) := ( b(j) - A[1:j-1,j]**T * x[1:j-1] ) / A(j,j)

end

We simultaneously compute two bounds

G(j) = bound on ( b(i) - A[1:i-1,i]**T * x[1:i-1] ), 1<=i<=j

M(j) = bound on x(i), 1<=i<=j

The initial values are G(0) = 0, M(0) = max{b(i), i=1,..,n}, and we

add the constraint G(j) >= G(j-1) and M(j) >= M(j-1) for j >= 1.

Then the bound on x(j) is

M(j) <= M(j-1) * ( 1 + CNORM(j) ) / | A(j,j) |

<= M(0) * product ( ( 1 + CNORM(i) ) / |A(i,i)| )

1<=i<=j

and we can safely call STRSV if 1/M(n) and 1/G(n) are both greater

than max(underflow, 1/overflow).

## subroutine slauu2 (character UPLO, integer N, real, dimension( lda, * ) A, integer LDA, integer INFO)¶

**SLAUU2** computes the product UUH or LHL, where U and L are
upper or lower triangular matrices (unblocked algorithm).

**Purpose:**

SLAUU2 computes the product U * U**T or L**T * L, where the triangular

factor U or L is stored in the upper or lower triangular part of

the array A.

If UPLO = 'U' or 'u' then the upper triangle of the result is stored,

overwriting the factor U in A.

If UPLO = 'L' or 'l' then the lower triangle of the result is stored,

overwriting the factor L in A.

This is the unblocked form of the algorithm, calling Level 2 BLAS.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the triangular factor stored in the array A

is upper or lower triangular:

= 'U': Upper triangular

= 'L': Lower triangular

*N*

N is INTEGER

The order of the triangular factor U or L. N >= 0.

*A*

A is REAL array, dimension (LDA,N)

On entry, the triangular factor U or L.

On exit, if UPLO = 'U', the upper triangle of A is

overwritten with the upper triangle of the product U * U**T;

if UPLO = 'L', the lower triangle of A is overwritten with

the lower triangle of the product L**T * L.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,N).

*INFO*

INFO is INTEGER

= 0: successful exit

< 0: if INFO = -k, the k-th argument had an illegal value

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine slauum (character UPLO, integer N, real, dimension( lda, * ) A, integer LDA, integer INFO)¶

**SLAUUM** computes the product UUH or LHL, where U and L are
upper or lower triangular matrices (blocked algorithm).

**Purpose:**

SLAUUM computes the product U * U**T or L**T * L, where the triangular

factor U or L is stored in the upper or lower triangular part of

the array A.

If UPLO = 'U' or 'u' then the upper triangle of the result is stored,

overwriting the factor U in A.

If UPLO = 'L' or 'l' then the lower triangle of the result is stored,

overwriting the factor L in A.

This is the blocked form of the algorithm, calling Level 3 BLAS.

**Parameters**

*UPLO*

UPLO is CHARACTER*1

Specifies whether the triangular factor stored in the array A

is upper or lower triangular:

= 'U': Upper triangular

= 'L': Lower triangular

*N*

N is INTEGER

The order of the triangular factor U or L. N >= 0.

*A*

A is REAL array, dimension (LDA,N)

On entry, the triangular factor U or L.

On exit, if UPLO = 'U', the upper triangle of A is

overwritten with the upper triangle of the product U * U**T;

if UPLO = 'L', the lower triangle of A is overwritten with

the lower triangle of the product L**T * L.

*LDA*

LDA is INTEGER

The leading dimension of the array A. LDA >= max(1,N).

*INFO*

INFO is INTEGER

= 0: successful exit

< 0: if INFO = -k, the k-th argument had an illegal value

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine srscl (integer N, real SA, real, dimension( * ) SX, integer INCX)¶

**SRSCL** multiplies a vector by the reciprocal of a real
scalar.

**Purpose:**

SRSCL multiplies an n-element real vector x by the real scalar 1/a.

This is done without overflow or underflow as long as

the final result x/a does not overflow or underflow.

**Parameters**

*N*

N is INTEGER

The number of components of the vector x.

*SA*

SA is REAL

The scalar a which is used to divide each component of x.

SA must be >= 0, or the subroutine will divide by zero.

*SX*

SX is REAL array, dimension

(1+(N-1)*abs(INCX))

The n-element vector x.

*INCX*

INCX is INTEGER

The increment between successive values of the vector SX.

> 0: SX(1) = X(1) and SX(1+(i-1)*INCX) = x(i), 1< i<= n

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

## subroutine stprfb (character SIDE, character TRANS, character DIRECT, character STOREV, integer M, integer N, integer K, integer L, real, dimension( ldv, * ) V, integer LDV, real, dimension( ldt, * ) T, integer LDT, real, dimension( lda, * ) A, integer LDA, real, dimension( ldb, * ) B, integer LDB, real, dimension( ldwork, * ) WORK, integer LDWORK)¶

**STPRFB** applies a real or complex 'triangular-pentagonal'
blocked reflector to a real or complex matrix, which is composed of two
blocks.

**Purpose:**

STPRFB applies a real "triangular-pentagonal" block reflector H or its

conjugate transpose H^H to a real matrix C, which is composed of two

blocks A and B, either from the left or right.

**Parameters**

*SIDE*

SIDE is CHARACTER*1

= 'L': apply H or H^H from the Left

= 'R': apply H or H^H from the Right

*TRANS*

TRANS is CHARACTER*1

= 'N': apply H (No transpose)

= 'C': apply H^H (Conjugate transpose)

*DIRECT*

DIRECT is CHARACTER*1

Indicates how H is formed from a product of elementary

reflectors

= 'F': H = H(1) H(2) . . . H(k) (Forward)

= 'B': H = H(k) . . . H(2) H(1) (Backward)

*STOREV*

STOREV is CHARACTER*1

Indicates how the vectors which define the elementary

reflectors are stored:

= 'C': Columns

= 'R': Rows

*M*

M is INTEGER

The number of rows of the matrix B.

M >= 0.

*N*

N is INTEGER

The number of columns of the matrix B.

N >= 0.

*K*

K is INTEGER

The order of the matrix T, i.e. the number of elementary

reflectors whose product defines the block reflector.

K >= 0.

*L*

L is INTEGER

The order of the trapezoidal part of V.

K >= L >= 0. See Further Details.

*V*

V is REAL array, dimension

(LDV,K) if STOREV = 'C'

(LDV,M) if STOREV = 'R' and SIDE = 'L'

(LDV,N) if STOREV = 'R' and SIDE = 'R'

The pentagonal matrix V, which contains the elementary reflectors

H(1), H(2), ..., H(K). See Further Details.

*LDV*

LDV is INTEGER

The leading dimension of the array V.

If STOREV = 'C' and SIDE = 'L', LDV >= max(1,M);

if STOREV = 'C' and SIDE = 'R', LDV >= max(1,N);

if STOREV = 'R', LDV >= K.

*T*

T is REAL array, dimension (LDT,K)

The triangular K-by-K matrix T in the representation of the

block reflector.

*LDT*

LDT is INTEGER

The leading dimension of the array T.

LDT >= K.

*A*

A is REAL array, dimension

(LDA,N) if SIDE = 'L' or (LDA,K) if SIDE = 'R'

On entry, the K-by-N or M-by-K matrix A.

On exit, A is overwritten by the corresponding block of

H*C or H^H*C or C*H or C*H^H. See Further Details.

*LDA*

LDA is INTEGER

The leading dimension of the array A.

If SIDE = 'L', LDA >= max(1,K);

If SIDE = 'R', LDA >= max(1,M).

*B*

B is REAL array, dimension (LDB,N)

On entry, the M-by-N matrix B.

On exit, B is overwritten by the corresponding block of

H*C or H^H*C or C*H or C*H^H. See Further Details.

*LDB*

LDB is INTEGER

The leading dimension of the array B.

LDB >= max(1,M).

*WORK*

WORK is REAL array, dimension

(LDWORK,N) if SIDE = 'L',

(LDWORK,K) if SIDE = 'R'.

*LDWORK*

LDWORK is INTEGER

The leading dimension of the array WORK.

If SIDE = 'L', LDWORK >= K;

if SIDE = 'R', LDWORK >= M.

**Author**

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

**Date**

**Further Details:**

The matrix C is a composite matrix formed from blocks A and B.

The block B is of size M-by-N; if SIDE = 'R', A is of size M-by-K,

and if SIDE = 'L', A is of size K-by-N.

If SIDE = 'R' and DIRECT = 'F', C = [A B].

If SIDE = 'L' and DIRECT = 'F', C = [A]

[B].

If SIDE = 'R' and DIRECT = 'B', C = [B A].

If SIDE = 'L' and DIRECT = 'B', C = [B]

[A].

The pentagonal matrix V is composed of a rectangular block V1 and a

trapezoidal block V2. The size of the trapezoidal block is determined by

the parameter L, where 0<=L<=K. If L=K, the V2 block of V is triangular;

if L=0, there is no trapezoidal block, thus V = V1 is rectangular.

If DIRECT = 'F' and STOREV = 'C': V = [V1]

[V2]

- V2 is upper trapezoidal (first L rows of K-by-K upper triangular)

If DIRECT = 'F' and STOREV = 'R': V = [V1 V2]

- V2 is lower trapezoidal (first L columns of K-by-K lower triangular)

If DIRECT = 'B' and STOREV = 'C': V = [V2]

[V1]

- V2 is lower trapezoidal (last L rows of K-by-K lower triangular)

If DIRECT = 'B' and STOREV = 'R': V = [V2 V1]

- V2 is upper trapezoidal (last L columns of K-by-K upper triangular)

If STOREV = 'C' and SIDE = 'L', V is M-by-K with V2 L-by-K.

If STOREV = 'C' and SIDE = 'R', V is N-by-K with V2 L-by-K.

If STOREV = 'R' and SIDE = 'L', V is K-by-M with V2 K-by-L.

If STOREV = 'R' and SIDE = 'R', V is K-by-N with V2 K-by-L.

# Author¶

Generated automatically by Doxygen for LAPACK from the source code.

Sat Aug 1 2020 | Version 3.9.0 |