LAPACK Auxiliary Routines
?lacgv
conjugates a complex vector.
?lacrm
multiplies a complex matrix by a square real matrix.
?lacrt
performs a linear transformation of a pair of complex vectors.
?laesy
computes the eigenvalues and eigenvectors of a 2-by-2 complex symmetric matrix,
and checks that the norm of
the matrix of eigenvectors is larger than a threshold value.
?rot
applies a plane rotation with real cosine and complex sine to a pair of complex vectors.
?spmv
computes a matrix-vector product for complex vectors using a complex symmetric packed matrix.
?spr
performs the symmetrical rank-1 update of a complex symmetric packed matrix.
?symv
computes a matrix-vector product for a complex symmetric matrix.
?syr
performs the symmetric rank-1 update of a complex symmetric matrix.
i?max1
finds the index of the vector element whose real part has maximum absolute value.
ilaenv
is an environmental enquiry function that returns values for tuning algorithmic performance.
lsame
tests two characters for equality regardless of case.
lsamen
tests two character strings for equality regardless of case.
?sum1
forms the 1-norm of the complex vector using the true absolute value.
?gbtf2
computes the LU factorization of a general band matrix using the unblocked version of the algorithm.
?gebd2
reduces a general matrix to bidiagonal form using an unblocked algorithm.
?gehd2
reduces a general square matrix to upper Hessenberg form using an unblocked algorithm.
?gelq2
computes the LQ factorization of a general rectangular matrix using an unblocked algorithm.
?geql2
computes the QL factorization of a general rectangular matrix using an unblocked algorithm.
?geqr2
computes the QR factorization of a general rectangular matrix using an unblocked algorithm.
?gerq2
computes the RQ factorization of a general rectangular matrix using an unblocked algorithm.
?gesc2
solves a system of linear equations using the LU factorization with complete pivoting computed by
?getc2.
?getc2
computes the LU factorization with complete pivoting of the general
?getf2
computes the LU factorization of a general
?gtts2
solves a system of linear equations with a tridiagonal matrix using the LU factorization computed by
?gttrf.
?labad
returns the square root of the underflow and overflow thresholds, if the exponent-range is very large.
?labrd
reduces the first
?lacon
estimates the 1-norm of a square matrix, using reverse communication for evaluating matrix-vector products.
?lacpy
copies all or part of one two-dimensional array to another.
?ladiv
performs complex division in real arithmetic, avoiding unnecessary overflow.
?lae2
computes the eigenvalues of a 2-by-2 symmetric matrix.
?laebz
computes the number of eigenvalues of a real symmetric tridiagonal matrix that are less than or equal to a given value, and performs other tasks required by the routine ?stebz.
?laed0
is used by ?stedc. Computes all eigenvalues and corresponding eigenvectors of an unreduced symmetric tridiagonal matrix using the divide and conquer method.
?laed1
is used by sstedc/dstedc. Computes the updated eigensystem of a diagonal matrix after modification by a rank-1 symmetric matrix. Used when the original matrix is tridiagonal.
?laed2
is used by sstedc/dstedc. Merges eigenvalues and deflates secular equation. Used when the original matrix is tridiagonal.
?laed3
is used by sstedc/dstedc. Finds the roots of the secular equation and updates the eigenvectors. Used when the original matrix is tridiagonal.
?laed4
is used by sstedc/dstedc. Finds a single root of the secular equation.
?laed5
is used by sstedc/dstedc. Solves the 2-by-2 secular equation.
?laed6
is used by sstedc/dstedc. Computes one Newton step in solution of the secular equation.
?laed7
is used by ?stedc. Computes the updated eigensystem of a diagonal matrix after modification by a rank-1 symmetric matrix. Used when the original matrix is dense.
?laed8
is used by ?stedc. Merges eigenvalues and deflates secular equation. Used when the original matrix is dense.
?laed9
is used by sstedc/dstedc. Finds the roots of the secular equation and updates the eigenvectors. Used when the original matrix is dense.
?laeda
is used by ?stedc. Computes the Z vector determining the rank-1 modification of the diagonal matrix. Used when the original matrix is dense.
?laein
computes a specified right or left eigenvector of an upper Hessenberg matrix by inverse iteration.
?laev2
computes the eigenvalues and eigenvectors of a 2-by-2 symmetric/Hermitian matrix.
?laexc
swaps adjacent diagonal blocks of a real upper quasi-triangular matrix in Schur canonical form by an orthogonal similarity transformation.
?lag2
computes the eigenvalues of a 2-by-2 generalized eigenvalue problem, with scaling as necessary to avoid over-/underflow.
?lags2
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.
?lagtf
computes an LU factorization of a matrix T-lI, where T is a general tridiagonal matrix and l is a scalar, using partial pivoting with row interchanges.
?lagtm
performs a matrix-matrix product of the form C = aAB+bC, where A is a tridiagonal matrix, B and C are rectangular matrices, and a and b are scalars, which may be 0, 1, or -1.
?lagts
solves the system of equations (T-lI)x= y or (T-lI)Tx = y , where T is a general tridiagonal matrix and l is a scalar, using the LU factorization computed by ?lagtf.
?lagv2
computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B), where B is the upper triangular.
?lahqr
computes the eigenvalues and Schur factorization of an upper Hessenberg matrix, using the double-shift/single-shift QR algorithm.
?lahrd
reduces the first
?laic1
applies one step of incremental condition estimation.
?laln2
solves a 1-by-1 or 2-by-2 linear system of equations of the specified form.
?lals0
applies back multiplying factors in solving the least squares problem using the divide and conquer SVD approach. Used by ?gelsd.
?lalsa
computes the SVD of the coefficient matrix in compact form. Used by ?gelsd.
?lalsd
uses the singular value decomposition of A to solve the least squares problem.
?lamch
determines machine parameters for floating-point arithmetic.
?lamc1
is called from ?lamc2. Determines machine parameters given by
?lamc2
is used by ?lamch. Determines machine parameters specified in its arguments list.
?lamc3
is called from ?lamc1-?lamc5. Intended to force
?lamc4
is a service routine for ?lamc2.
?lamc5
is called from ?lamc2. Attempts to compute the largest machine floating-point number, without overflow.
?lamrg
creates a permutation list to merge the entries of two independently
sorted sets into a single set sorted in acsending order.
?langb
returns the value of the 1-norm, Frobenius norm, infinity-norm,
or the largest absolute value of any element of a general band matrix.
?lange
returns the value of the 1-norm, Frobenius norm, infinity-norm, or
the largest absolute value of any element of a general rectangular matrix.
?langt
returns the value of the 1-norm, Frobenius norm, infinity-norm, or
the largest absolute value of any element of a general tridiagonal matrix.
?lanhs
returns the value of the 1-norm, Frobenius norm, infinity-norm, or
the largest absolute value of any element of an upper Hessenberg matrix.
?lansb
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.
?lanhb
returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,
or the element of largest absolute value of a Hermitian band matrix.
?lansp
returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,
or the element of largest absolute value of a real symmetric matrix supplied in packed form.
?lanhp
returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,
or the element of largest absolute value of a complex Hermitian matrix supplied in packed form.
?lanst/?lanht
returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,
or the element of largest absolute value of a real symmetric or complex Hermitian tridiagonal matrix.
?lansy
returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,
or the element of largest absolute value of a real/complex symmetric matrix.
?lanhe
returns the value of the 1-norm, or the Frobenius norm, or the infinity norm,
or the element of largest absolute value of a complex Hermitian matrix.
?lantb
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.
?lantp
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.
?lantr
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.
?lanv2
computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form.
?lapll
measures the linear dependence of two vectors.
?lapmt
performs a forward or backward permutation of the columns of a matrix.
?lapy2
returns sqrt(
?lapy3
returns sqrt(
?laqgb
scales a general band matrix, using row and column scaling factors computed by ?gbequ.
?laqge
scales a general rectangular matrix, using row and column scaling factors computed by ?geequ.
?laqp2
computes a QR factorization with column pivoting of the matrix block.
?laqps
computes a step of QR factorization with column pivoting of a real
?laqsb
scales a symmetric/Hermitian band matrix, using scaling factors computed by ?pbequ.
?laqsp
scales a symmetric/Hermitian matrix in packed storage, using scaling factors computed by ?ppequ.
?laqsy
scales a symmetric/Hermitian matrix, using scaling factors computed by ?poequ.
?laqtr
solves a real quasi-triangular system of equations, or a complex quasi-triangular system of special form, in real arithmetic.
?lar1v
computes the (scaled)
?lar2v
applies a vector of plane rotations with real cosines and real/complex sines from both sides to a sequence of 2-by-2 symmetric/Hermitian matrices.
?larf
applies an elementary reflector to a general rectangular matrix.
?larfb
applies a block reflector or its transpose/conjugate-transpose to a general rectangular matrix.
?larfg
generates an elementary reflector (Householder matrix).
?larft
forms the triangular factor T of a block reflector H = I - VTVH.
?larfx
applies an elementary reflector to a general rectangular matrix, with loop unrolling when the reflector has order Ј 10.
?largv
generates a vector of plane rotations with real cosines and real/complex sines.
?larnv
returns a vector of random numbers from a uniform or normal distribution.
?larrb
provides limited bisection to locate eigenvalues for more accuracy.
?larre
sets small off-diagonal elements of the tridiagonal matrix T to zero and finds base representations and eigenvalues for each unreduced block Ti .
?larrf
finds a new relatively robust representation such that at least one of the eigenvalues is relatively isolated.
?larrv
computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D, and the eigenvalues of L D LT.
?lartg
generates a plane rotation with real cosine and real/complex sine.
?lartv
applies a vector of plane rotations with real cosines and real/complex sines to the elements of a pair of vectors.
?laruv
returns a vector of
?larz
applies an elementary reflector (as returned by ?tzrzf) to a general matrix.
?larzb
applies a block reflector or its transpose/conjugate-transpose to a general matrix.
?larzt
forms the triangular factor T of a block reflector H = I - VTVH.
?las2
computes singular values of a 2-by-2 triangular matrix.
?lascl
multiplies a general rectangular matrix by a real scalar defined as
?lasd0
computes the singular values of a real upper bidiagonal
?lasd1
computes the SVD of an upper bidiagonal matrix B of the specified size. Used by ?bdsdc.
?lasd2
merges the two sets of singular values together into a single sorted set. Used by ?bdsdc.
?lasd3
finds all square roots of the roots of the secular equation, as defined by the values in D and Z, and then updates the singular vectors by matrix multiplication. Used by ?bdsdc.
?lasd4
computes the square root of the
?lasd5
computes the square root of the
?lasd6
computes the SVD of an updated upper bidiagonal matrix obtained by merging two smaller ones by appending a row. Used by ?bdsdc.
?lasd7
merges the two sets of singular values together into a single sorted set and then attempts to deflate the size of the problem. Used by ?bdsdc.
?lasd8
finds the square roots of the roots of the secular equation and stores for each element in D the distance to its two nearest poles. Used by ?bdsdc.
?lasd9
finds the square roots of the roots of the secular equation and stores for each element in D the distance to its two nearest poles. Used by ?bdsdc.
?lasda
computes the SVD of a real upper bidiagonal matrix with diagonal
?lasdq
computes the SVD of a real bidiagonal matrix with diagonal
?lasdt
creates a tree of subproblems for bidiagonal divide and conquer. Used by ?bdsdc.
?laset
initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
?lasq1
computes the singular values of a real square bidiagonal matrix. Used by ?bdsqr.
?lasq2
computes all the eigenvalues of the symmetric positive definite tridiagonal matrix associated with the qd array
?lasq3
checks for deflation, computes a shift, and calls dqds. Used by ?bdsqr.
?lasq4
computes an approximation to the smallest eigenvalue using values of d from the previous transform. Used by ?bdsqr.
?lasq5
computes one dqds transform in ping-pong form. Used by ?bdsqr and ?stegr.
?lasq6
computes one dqds transform in ping-pong form. Used by ?bdsqr and ?stegr.
?lasr
applies a sequence of plane rotations to a general rectangular matrix.
?lasrt
sorts numbers in increasing or decreasing order.
?lassq
updates a sum of squares represented in scaled form.
?lasv2
computes the SVD of a 2-by-2 triangular matrix.
?laswp
performs a series of row interchanges on a general rectangular matrix.
?lasy2
solves the Sylvester matrix equation, where the matrices are of order 1 or 2.
?lasyf
computes a partial factorization of a real/complex symmetric matrix, using the diagonal pivoting method.
?lahef
computes a partial factorization of a complex Hermitian indefinite matrix, using the diagonal pivoting method.
?latbs
solves a triangular banded system of equations.
?latdf
uses the LU factorization of the
?latps
solves a triangular system of equations with the matrix held in packed storage.
?latrd
reduces the first
?latrs
solves a triangular system of equations with the scale factor set to prevent overflow.
?latrz
factors an upper trapezoidal matrix by means of orthogonal/unitary transformations.
?lauu2
computes the product U U H or LH L, where U and L are upper or lower triangular matrices (unblocked algorithm).
?lauum
computes the product U U H or LH L, where U and L are upper or lower triangular matrices.
?org2l/?ung2l
generates all or part of the orthogonal/unitary matrix Q from a QL factorization determined by ?geqlf (unblocked algorithm).
?org2r/?ung2r
generates all or part of the orthogonal/unitary matrix Q from a QR factorization determined by ?geqrf (unblocked algorithm).
?orgl2/?ungl2
generates all or part of the orthogonal/unitary matrix Q from an LQ factorization determined by ?gelqf (unblocked algorithm).
?orgr2/?ungr2
generates all or part of the orthogonal/unitary matrix Q from an RQ factorization determined by ?gerqf (unblocked algorithm).
?orm2l/?unm2l
multiplies a general matrix by the orthogonal/unitary matrix from a QL factorization determined by ?geqlf (unblocked algorithm).
?orm2r/?unm2r
multiplies a general matrix by the orthogonal/unitary matrix from a QR factorization determined by ?geqrf (unblocked algorithm).
?orml2/?unml2
multiplies a general matrix by the orthogonal/unitary matrix from an LQ factorization determined by ?gelqf (unblocked algorithm).
?ormr2/?unmr2
multiplies a general matrix by the orthogonal/unitary matrix from an RQ factorization determined by ?gerqf (unblocked algorithm).
?ormr3/?unmr3
multiplies a general matrix by the orthogonal/unitary matrix from an RZ factorization determined by ?tzrzf (unblocked algorithm).
?pbtf2
computes the Cholesky factorization of a symmetric/Hermitian positive definite band matrix (unblocked algorithm).
?potf2
computes the Cholesky factorization of a symmetric/Hermitian positive definite matrix (unblocked algorithm).
?ptts2
solves a tridiagonal system of the form AX=B using the L D LH factorization computed by ?pttrf.
?rscl
multiplies a vector by the reciprocal of a real scalar.
?sygs2/?hegs2
reduces a symmetric/Hermitian definite generalized eigenproblem to standard form, using the factorization results obtained from ?potrf (unblocked algorithm).
?sytd2/?hetd2
reduces a symmetric/Hermitian matrix to real symmetric tridiagonal form by an orthogonal/unitary similarity transformation (unblocked algorithm).
?sytf2
computes the factorization of a real/complex symmetric indefinite matrix, using the diagonal pivoting method (unblocked algorithm).
?hetf2
computes the factorization of a complex Hermitian matrix, using the diagonal pivoting method (unblocked algorithm).
?tgex2
swaps adjacent diagonal blocks in an upper (quasi)triangular matrix pair by an orthogonal/unitary equivalence transformation.
?tgsy2
solves the generalized Sylvester equation (unblocked algorithm).
?trti2
computes the inverse of a triangular matrix (unblocked algorithm).
xerbla
is an error handling routine called by LAPACK routines.
call clacgv (n, x, incx)
call zlacgv (n, x, incx)
call clacrm (m, n, a, lda, b, ldb, c, ldc, rwork)
call zlacrm (m, n, a, lda, b, ldb, c, ldc, rwork)
call clacrt (n, cx, incx, cy, incy, c, s)
call zlacrt (n, cx, incx, cy, incy, c, s)
call claesy (a, b, c, rt1, rt2, evscal, cs1, sn1)
call zlaesy (a, b, c, rt1, rt2, evscal, cs1, sn1)
call crot (n, cx, incx, cy, incy, c, s)
call zrot (n, cx, incx, cy, incy, c, s)
call cspmv (uplo, n, alpha, ap, x, incx, beta, y, incy)
call zspmv (uplo, n, alpha, ap, x, incx, beta, y, incy)
call cspr (uplo, n, alpha, x, incx, ap)
call zspr (uplo, n, alpha, x, incx, ap)
call csymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
call zsymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
call csyr (uplo, n, alpha, x, incx, a, lda)
call zsyr (uplo, n, alpha, x, incx, a, lda)
index = icmax1 (n, cx, incx)
index = izmax1 (n, cx, incx)
value = ilaenv (ispec, name, opts, n1, n2, n3, n4)
val = lsame (ca, cb)
val = lsamen (n, ca, cb)
res = scsum1 (n, cx, incx)
res = dzsum1 (n, cx, incx)
call sgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info)
call dgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info)
call cgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info)
call zgbtf2 (m, n, kl, ku, ab, ldab, ipiv, info)
call sgebd2 (m, n, a, lda, d, e, tauq, taup, work, info)
call dgebd2 (m, n, a, lda, d, e, tauq, taup, work, info)
call cgebd2 (m, n, a, lda, d, e, tauq, taup, work, info)
call zgebd2 (m, n, a, lda, d, e, tauq, taup, work, info)
call sgehd2 (n, ilo, ihi, a, lda, tau, work, info)
call dgehd2 (n, ilo, ihi, a, lda, tau, work, info)
call cgehd2 (n, ilo, ihi, a, lda, tau, work, info)
call zgehd2 (n, ilo, ihi, a, lda, tau, work, info)
call sgelq2 (m, n, a, lda, tau, work, info)
call dgelq2 (m, n, a, lda, tau, work, info)
call cgelq2 (m, n, a, lda, tau, work, info)
call zgelq2 (m, n, a, lda, tau, work, info)
call sgeql2 (m, n, a, lda, tau, work, info)
call dgeql2 (m, n, a, lda, tau, work, info)
call cgeql2 (m, n, a, lda, tau, work, info)
call zgeql2 (m, n, a, lda, tau, work, info)
call sgeqr2 (m, n, a, lda, tau, work, info)
call dgeqr2 (m, n, a, lda, tau, work, info)
call cgeqr2 (m, n, a, lda, tau, work, info)
call zgeqr2 (m, n, a, lda, tau, work, info)
call sgerq2 (m, n, a, lda, tau, work, info)
call dgerq2 (m, n, a, lda, tau, work, info)
call cgerq2 (m, n, a, lda, tau, work, info)
call zgerq2 (m, n, a, lda, tau, work, info)
call sgesc2 (n, a, lda, rhs, ipiv, jpiv, scale)
call dgesc2 (n, a, lda, rhs, ipiv, jpiv, scale)
call cgesc2 (n, a, lda, rhs, ipiv, jpiv, scale)
call zgesc2 (n, a, lda, rhs, ipiv, jpiv, scale)
n
-by-n
matrix.
call sgetc2 (n, a, lda, ipiv, jpiv, info)
call dgetc2 (n, a, lda, ipiv, jpiv, info)
call cgetc2 (n, a, lda, ipiv, jpiv, info)
call zgetc2 (n, a, lda, ipiv, jpiv, info)
m
-by-n
matrix using partial pivoting with row interchanges (unblocked algorithm).
call sgetf2 (m, n, a, lda, ipiv, info)
call dgetf2 (m, n, a, lda, ipiv, info)
call cgetf2 (m, n, a, lda, ipiv, info)
call zgetf2 (m, n, a, lda, ipiv, info)
call sgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb)
call dgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb)
call cgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb)
call zgtts2 (itrans, n, nrhs, dl, d, du, du2, ipiv, b, ldb)
call slabad (small, large)
call dlabad (small, large)
nb
rows and columns of a general matrix to a bidiagonal form.
call slabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)
call dlabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)
call clabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)
call zlabrd (m, n, nb, a, lda, d, e, tauq, taup, x, ldx, y, ldy)
call slacon (n, v, x, isgn, est, kase)
call dlacon (n, v, x, isgn, est, kase)
call clacon (n, v, x, est, kase)
call zlacon (n, v, x, est, kase)
call slacpy (uplo, m, n, a, lda, b, ldb)
call dlacpy (uplo, m, n, a, lda, b, ldb)
call clacpy (uplo, m, n, a, lda, b, ldb)
call zlacpy (uplo, m, n, a, lda, b, ldb)
call sladiv (a, b, c, d, p, q)
call dladiv (a, b, c, d, p, q)
res = cladiv (x, y)
res = zladiv (x, y)
call slae2 (a, b, c, rt1, rt2)
call dlae2 (a, b, c, rt1, rt2)
call slaebz (ijob, nitmax, n, mmax, minp, nbmin, abstol,
reltol, pivmin, d, e, e2, nval, ab, c, mout, nab,
work, iwork, info)
call dlaebz (ijob, nitmax, n, mmax, minp, nbmin, abstol,
reltol, pivmin, d, e, e2, nval, ab, c, mout, nab,
work, iwork, info)
call slaed0 (icompq, qsiz, n, d, e, q, ldq, qstore, ldqs,
work, iwork, info)
call dlaed0 (icompq, qsiz, n, d, e, q, ldq, qstore, ldqs,
work, iwork, info)
call claed0 (qsiz, n, d, e, q, ldq, qstore, ldqs, rwork,
iwork, info)
call zlaed0 (qsiz, n, d, e, q, ldq, qstore, ldqs, rwork,
iwork, info)
call slaed1 (n, d, q, ldq, indxq, rho, cutpnt, work,
iwork, info)
call dlaed1 (n, d, q, ldq, indxq, rho, cutpnt, work,
iwork, info)
call slaed2 (k, n, n1, d, q, ldq, indxq, rho, z, dlamda,
w, q2, indx, indxc, indxp, coltyp, info)
call dlaed2 (k, n, n1, d, q, ldq, indxq, rho, z, dlamda,
w, q2, indx, indxc, indxp, coltyp, info)
call slaed3 (k, n, n1, d, q, ldq, rho, dlamda, q2, indx,
ctot, w, s, info)
call dlaed3 (k, n, n1, d, q, ldq, rho, dlamda, q2, indx,
ctot, w, s, info)
call slaed4 (n, i, d, z, delta, rho, dlam, info)
call dlaed4 (n, i, d, z, delta, rho, dlam, info)
call slaed5 (i, d, z, delta, rho, dlam)
call dlaed5 (i, d, z, delta, rho, dlam)
call slaed6 (kniter, orgati, rho, d, z, finit, tau, info)
call dlaed6 (kniter, orgati, rho, d, z, finit, tau, info)
call slaed7 (icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq,
indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol,
givnum, work, iwork, info)
call dlaed7 (icompq, n, qsiz, tlvls, curlvl, curpbm, d, q, ldq,
indxq, rho, cutpnt, qstore, qptr, prmptr, perm, givptr, givcol,
givnum, work, iwork, info)
call claed7 (n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho,
indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum,
work, rwork, iwork, info)
call zlaed7 (n, cutpnt, qsiz, tlvls, curlvl, curpbm, d, q, ldq, rho,
indxq, qstore, qptr, prmptr, perm, givptr, givcol, givnum,
work, rwork, iwork, info)
call slaed8 (icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z,
dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx,
info)
call dlaed8 (icompq, k, n, qsiz, d, q, ldq, indxq, rho, cutpnt, z,
dlamda, q2, ldq2, w, perm, givptr, givcol, givnum, indxp, indx,
info)
call claed8 (k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2,
ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum,
info)
call zlaed8 (k, n, qsiz, q, ldq, d, rho, cutpnt, z, dlamda, q2,
ldq2, w, indxp, indx, indxq, perm, givptr, givcol, givnum,
info)
call slaed9 (k, kstart, kstop, n, d, q, ldq, rho,
dlamda, w, s, lds, info)
call dlaed9 (k, kstart, kstop, n, d, q, ldq, rho,
dlamda, w, s, lds, info)
call slaeda (n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol,
givnum, q, qptr, z, ztemp, info)
call dlaeda (n, tlvls, curlvl, curpbm, prmptr, perm, givptr, givcol,
givnum, q, qptr, z, ztemp, info)
call slaein (rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb,
work, eps3, smlnum, bignum, info)
call dlaein (rightv, noinit, n, h, ldh, wr, wi, vr, vi, b, ldb,
work, eps3, smlnum, bignum, info)
call claein (rightv, noinit, n, h, ldh, w, v, b, ldb,
rwork, eps3, smlnum, info)
call zlaein (rightv, noinit, n, h, ldh, w, v, b, ldb,
rwork, eps3, smlnum, info)
call slaev2 (a, b, c, rt1, rt2, cs1, sn1)
call dlaev2 (a, b, c, rt1, rt2, cs1, sn1)
call claev2 (a, b, c, rt1, rt2, cs1, sn1)
call zlaev2 (a, b, c, rt1, rt2, cs1, sn1)
call slaexc (wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info)
call dlaexc (wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info)
call slag2 (a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi)
call dlag2 (a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi)
call slags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu,
csv, snv, csq, snq)
call dlags2 (upper, a1, a2, a3, b1, b2, b3, csu, snu,
csv, snv, csq, snq)
call slagtf (n, a, lambda, b, c, tol, d, in, info)
call dlagtf (n, a, lambda, b, c, tol, d, in, info)
call slagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
call dlagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
call clagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
call zlagtm (trans, n, nrhs, alpha, dl, d, du, x, ldx, beta, b, ldb)
call slagts (job, n, a, b, c, d, in, y, tol, info)
call dlagts (job, n, a, b, c, d, in, y, tol, info)
call slagv2 (a, lda, b, ldb, alphar, alphai, beta, csl,
snl, csr, snr)
call dlagv2 (a, lda, b, ldb, alphar, alphai, beta, csl,
snl, csr, snr)
call slahqr (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi,
iloz, ihiz, z, ldz, info)
call dlahqr (wantt, wantz, n, ilo, ihi, h, ldh, wr, wi,
iloz, ihiz, z, ldz, info)
call clahqr (wantt, wantz, n, ilo, ihi, h, ldh, w,
iloz, ihiz, z, ldz, info)
call zlahqr (wantt, wantz, n, ilo, ihi, h, ldh, w,
iloz, ihiz, z, ldz, info)
nb
columns of a general rectangular matrix A so that elements below the k
-th subdiagonal are zero, and returns auxiliary matrices that are needed to apply the transformation to the unreduced part of A.
call slahrd (n, k, nb, a, lda, tau, t, ldt, y, ldy)
call dlahrd (n, k, nb, a, lda, tau, t, ldt, y, ldy)
call clahrd (n, k, nb, a, lda, tau, t, ldt, y, ldy)
call zlahrd (n, k, nb, a, lda, tau, t, ldt, y, ldy)
call slaic1 (job, j, x, sest, w, gamma, sestpr, s, c)
call dlaic1 (job, j, x, sest, w, gamma, sestpr, s, c)
call claic1 (job, j, x, sest, w, gamma, sestpr, s, c)
call zlaic1 (job, j, x, sest, w, gamma, sestpr, s, c)
call slaln2 (ltrans, na, nw, smin, ca, a, lda, d1, d2,
b, ldb, wr, wi, x, ldx, scale, xnorm, info)
call dlaln2 (ltrans, na, nw, smin, ca, a, lda, d1, d2,
b, ldb, wr, wi, x, ldx, scale, xnorm, info)
call slals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx,
ldbx, perm, givptr, givcol, ldgcol, givnum,
ldgnum, poles, difl, difr, z, k, c, s, work,
info)
call dlals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx,
ldbx, perm, givptr, givcol, ldgcol, givnum,
ldgnum, poles, difl, difr, z, k, c, s, work,
info)
call clals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx,
ldbx, perm, givptr, givcol, ldgcol, givnum,
ldgnum, poles, difl, difr, z, k, c, s, work,
info)
call zlals0 (icompq, nl, nr, sqre, nrhs, b, ldb, bx,
ldbx, perm, givptr, givcol, ldgcol, givnum,
ldgnum, poles, difl, difr, z, k, c, s, work,
info)
call slalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx,
u, ldu, vt, k, difl, difr, z, poles, givptr,
givcol, ldgcol, perm, givnum, c, s, work,
iwork, info)
call dlalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx,
u, ldu, vt, k, difl, difr, z, poles, givptr,
givcol, ldgcol, perm, givnum, c, s, work,
iwork, info)
call clalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx,
u, ldu, vt, k, difl, difr, z, poles, givptr,
givcol, ldgcol, perm, givnum, c, s, rwork,
iwork, info)
call zlalsa (icompq, smlsiz, n, nrhs, b, ldb, bx, ldbx,
u, ldu, vt, k, difl, difr, z, poles, givptr,
givcol, ldgcol, perm, givnum, c, s, rwork,
iwork, info)
call slalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb,
rcond, rank, work,
iwork, info)
call dlalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb,
rcond, rank, work,
iwork, info)
call clalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb,
rcond, rank, work, rwork,
iwork, info)
call zlalsd (uplo, smlsiz, n, nrhs, d, e, b, ldb,
rcond, rank, work, rwork,
iwork, info)
val = slamch (cmach)
val = dlamch (cmach)
beta, t, rnd, ieeel
.
call slamc1 (beta, t, rnd, ieeel)
call dlamc1 (beta, t, rnd, ieeel)
call slamc2 (beta, t, rnd, eps, emin, rmin, emax, rmax)
call dlamc2 (beta, t, rnd, eps, emin, rmin, emax, rmax)
a
and b
to be stored prior to doing the addition of a
and b
.
val = slamc3 (a, b)
val = dlamc3 (a, b)
call slamc4 (emin, start, base)
call dlamc4 (emin, start, base)
call slamc5 (beta, p, emin, ieee, emax, rmax)
call dlamc5 (beta, p, emin, ieee, emax, rmax)
call slamrg (n1, n2, a, strd1, strd2, index)
call dlamrg (n1, n2, a, strd1, strd2, index)
val = slangb (norm, n, kl, ku, ab, ldab, work)
val = dlangb (norm, n, kl, ku, ab, ldab, work)
val = clangb (norm, n, kl, ku, ab, ldab, work)
val = zlangb (norm, n, kl, ku, ab, ldab, work)
val = slange (norm, m, n, a, lda, work)
val = dlange (norm, m, n, a, lda, work)
val = clange (norm, m, n, a, lda, work)
val = zlange (norm, m, n, a, lda, work)
val = slangt (norm, n, dl, d, du)
val = dlangt (norm, n, dl, d, du)
val = clangt (norm, n, dl, d, du)
val = zlangt (norm, n, dl, d, du)
val = slanhs (norm, n, a, lda, work)
val = dlanhs (norm, n, a, lda, work)
val = clanhs (norm, n, a, lda, work)
val = zlanhs (norm, n, a, lda, work)
val = slansb (norm, uplo, n, k, ab, ldab, work)
val = dlansb (norm, uplo, n, k, ab, ldab, work)
val = clansb (norm, uplo, n, k, ab, ldab, work)
val = zlansb (norm, uplo, n, k, ab, ldab, work)
val = clanhb (norm, uplo, n, k, ab, ldab, work)
val = zlanhb (norm, uplo, n, k, ab, ldab, work)
val = slansp (norm, uplo, n, ap, work)
val = dlansp (norm, uplo, n, ap, work)
val = clansp (norm, uplo, n, ap, work)
val = zlansp (norm, uplo, n, ap, work)
val = clanhp (norm, uplo, n, ap, work)
val = zlanhp (norm, uplo, n, ap, work)
val = slanst (norm, n, d, e)
val = dlanst (norm, n, d, e)
val = clanht (norm, n, d, e)
val = zlanht (norm, n, d, e)
val = slansy (norm, uplo, n, a, lda, work)
val = dlansy (norm, uplo, n, a, lda, work)
val = clansy (norm, uplo, n, a, lda, work)
val = zlansy (norm, uplo, n, a, lda, work)
val = clanhe (norm, uplo, n, a, lda, work)
val = zlanhe (norm, uplo, n, a, lda, work)
val = slantb (norm, uplo, diag, n, k, ab, ldab, work)
val = dlantb (norm, uplo, diag, n, k, ab, ldab, work)
val = clantb (norm, uplo, diag, n, k, ab, ldab, work)
val = zlantb (norm, uplo, diag, n, k, ab, ldab, work)
val = slantp (norm, uplo, diag, n, ap, work)
val = dlantp (norm, uplo, diag, n, ap, work)
val = clantp (norm, uplo, diag, n, ap, work)
val = zlantp (norm, uplo, diag, n, ap, work)
val = slantr (norm, uplo, diag, m, n, a, lda, work)
val = dlantr (norm, uplo, diag, m, n, a, lda, work)
val = clantr (norm, uplo, diag, m, n, a, lda, work)
val = zlantr (norm, uplo, diag, m, n, a, lda, work)
call slanv2 (a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn)
call dlanv2 (a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn)
call slapll (n, x, incx, y, incy, ssmin)
call dlapll (n, x, incx, y, incy, ssmin)
call clapll (n, x, incx, y, incy, ssmin)
call zlapll (n, x, incx, y, incy, ssmin)
call slapmt (forwrd, m, n, x, ldx, k)
call dlapmt (forwrd, m, n, x, ldx, k)
call clapmt (forwrd, m, n, x, ldx, k)
call zlapmt (forwrd, m, n, x, ldx, k)
x
2
+y
2).
val = slapy2 (x, y)
val = dlapy2 (x, y)
x
2+y
2+z
2).
val = slapy3 (x, y, z)
val = dlapy3 (x, y, z)
call slaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd,
colcnd, amax, equed)
call dlaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd,
colcnd, amax, equed)
call claqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd,
colcnd, amax, equed)
call zlaqgb (m, n, kl, ku, ab, ldab, r, c, rowcnd,
colcnd, amax, equed)
call slaqge (m, n, a, lda, r, c, rowcnd,
colcnd, amax, equed)
call dlaqge (m, n, a, lda, r, c, rowcnd,
colcnd, amax, equed)
call claqge (m, n, a, lda, r, c, rowcnd,
colcnd, amax, equed)
call zlaqge (m, n, a, lda, r, c, rowcnd,
colcnd, amax, equed)
call slaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
call dlaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
call claqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
call zlaqp2 (m, n, offset, a, lda, jpvt, tau, vn1, vn2, work)
m
-by-n
matrix A by using BLAS level 3.
call slaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
call dlaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
call claqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
call zlaqps (m, n, offset, nb, kb, a, lda, jpvt, tau, vn1, vn2, auxv, f, ldf)
call slaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
call dlaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
call claqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
call zlaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
call slaqsp (uplo, n, ap, s, scond, amax, equed)
call dlaqsp (uplo, n, ap, s, scond, amax, equed)
call claqsp (uplo, n, ap, s, scond, amax, equed)
call zlaqsp (uplo, n, ap, s, scond, amax, equed)
call slaqsy (uplo, n, a, lda, scond, amax, equed)
call dlaqsy (uplo, n, a, lda, scond, amax, equed)
call claqsy (uplo, n, a, lda, scond, amax, equed)
call zlaqsy (uplo, n, a, lda, scond, amax, equed)
call slaqtr (ltran, lreal, n, t, ldt, b, w, scale, x,
work, info)
call dlaqtr (ltran, lreal, n, t, ldt, b, w, scale, x,
work, info)
r
-th column of the inverse of the submatrix
in rows
b1
through bn
of the tridiagonal matrix LDLT - sI.
call slar1v (n, b1, bn, sigma, d, l, ld, lld, gersch, z,
ztz, mingma, r, isuppz, work)
call dlar1v (n, b1, bn, sigma, d, l, ld, lld, gersch, z,
ztz, mingma, r, isuppz, work)
call clar1v (n, b1, bn, sigma, d, l, ld, lld, gersch, z,
ztz, mingma, r, isuppz, work)
call zlar1v (n, b1, bn, sigma, d, l, ld, lld, gersch, z,
ztz, mingma, r, isuppz, work)
call slar2v (n, x, y, z, incx, c, s, incc)
call dlar2v (n, x, y, z, incx, c, s, incc)
call clar2v (n, x, y, z, incx, c, s, incc)
call zlar2v (n, x, y, z, incx, c, s, incc)
call slarf (side, m, n, v, incv, tau, c, ldc, work)
call dlarf (side, m, n, v, incv, tau, c, ldc, work)
call clarf (side, m, n, v, incv, tau, c, ldc, work)
call zlarf (side, m, n, v, incv, tau, c, ldc, work)
call slarfb (side, trans, direct, storev, m, n, k, v,
ldv, t, ldt, c, ldc, work, ldwork)
call dlarfb (side, trans, direct, storev, m, n, k, v,
ldv, t, ldt, c, ldc, work, ldwork)
call clarfb (side, trans, direct, storev, m, n, k, v,
ldv, t, ldt, c, ldc, work, ldwork)
call zlarfb (side, trans, direct, storev, m, n, k, v,
ldv, t, ldt, c, ldc, work, ldwork)
call slarfg (n, alpha, x, incx, tau)
call dlarfg (n, alpha, x, incx, tau)
call clarfg (n, alpha, x, incx, tau)
call zlarfg (n, alpha, x, incx, tau)
call slarft (direct, storev, n, k, v, ldv, tau, t, ldt)
call dlarft (direct, storev, n, k, v, ldv, tau, t, ldt)
call clarft (direct, storev, n, k, v, ldv, tau, t, ldt)
call zlarft (direct, storev, n, k, v, ldv, tau, t, ldt)
call slarfx (side, m, n, v, tau, c, ldc, work)
call dlarfx (side, m, n, v, tau, c, ldc, work)
call clarfx (side, m, n, v, tau, c, ldc, work)
call zlarfx (side, m, n, v, tau, c, ldc, work)
call slargv (n, x, incx, y, incy, c, incc)
call dlargv (n, x, incx, y, incy, c, incc)
call clargv (n, x, incx, y, incy, c, incc)
call zlargv (n, x, incx, y, incy, c, incc)
call slarnv (idist, iseed, n, x)
call dlarnv (idist, iseed, n, x)
call clarnv (idist, iseed, n, x)
call zlarnv (idist, iseed, n, x)
call slarrb (n, d, l, ld, lld, ifirst, ilast, sigma,
reltol, w, wgap, werr, work, iwork, info)
call dlarrb (n, d, l, ld, lld, ifirst, ilast, sigma,
reltol, w, wgap, werr, work, iwork, info)
call slarre (n, d, e, tol, nsplit, isplit, m, w, woff,
gersch, work, info)
call dlarre (n, d, e, tol, nsplit, isplit, m, w, woff,
gersch, work, info)
call slarrf (n, d, l, ld, lld, ifirst, ilast, w, dplus,
lplus, work, iwork, info)
call dlarrf (n, d, l, ld, lld, ifirst, ilast, w, dplus,
lplus, work, iwork, info)
call slarrv (n, d, l, isplit, m, w, iblock, gersch,
tol, z, ldz, isuppz, work, iwork, info)
call dlarrv (n, d, l, isplit, m, w, iblock, gersch,
tol, z, ldz, isuppz, work, iwork, info)
call clarrv (n, d, l, isplit, m, w, iblock, gersch,
tol, z, ldz, isuppz, work, iwork, info)
call zlarrv (n, d, l, isplit, m, w, iblock, gersch,
tol, z, ldz, isuppz, work, iwork, info)
call slartg (f, g, cs, sn, r)
call dlartg (f, g, cs, sn, r)
call clartg (f, g, cs, sn, r)
call zlartg (f, g, cs, sn, r)
call slartv (n, x, incx, y, incy, c, s, incc)
call dlartv (n, x, incx, y, incy, c, s, incc)
call clartv (n, x, incx, y, incy, c, s, incc)
call zlartv (n, x, incx, y, incy, c, s, incc)
n
random real numbers from a uniform distribution.
call slaruv (iseed, n, x)
call dlaruv (iseed, n, x)
call slarz (side, m, n, l, v, incv, tau, c, ldc, work)
call dlarz (side, m, n, l, v, incv, tau, c, ldc, work)
call clarz (side, m, n, l, v, incv, tau, c, ldc, work)
call zlarz (side, m, n, l, v, incv, tau, c, ldc, work)
call slarzb (side, trans, direct, storev, m, n, k, l,
v, ldv, t, ldt, c, ldc, work, ldwork)
call dlarzb (side, trans, direct, storev, m, n, k, l,
v, ldv, t, ldt, c, ldc, work, ldwork)
call clarzb (side, trans, direct, storev, m, n, k, l,
v, ldv, t, ldt, c, ldc, work, ldwork)
call zlarzb (side, trans, direct, storev, m, n, k, l,
v, ldv, t, ldt, c, ldc, work, ldwork)
call slarzt (direct, storev, n, k, v, ldv, tau, t, ldt)
call dlarzt (direct, storev, n, k, v, ldv, tau, t, ldt)
call clarzt (direct, storev, n, k, v, ldv, tau, t, ldt)
call zlarzt (direct, storev, n, k, v, ldv, tau, t, ldt)
call slas2 (f, g, h, ssmin, ssmax)
call dlas2 (f, g, h, ssmin, ssmax)
cto
/cfrom
.
call slascl (type, kl, ku, cfrom, cto, m, n, a, lda, info)
call dlascl (type, kl, ku, cfrom, cto, m, n, a, lda, info)
call clascl (type, kl, ku, cfrom, cto, m, n, a, lda, info)
call zlascl (type, kl, ku, cfrom, cto, m, n, a, lda, info)
n
-by-m
matrix B
with diagonal d
and off-diagonal e
. Used by ?bdsdc.
call slasd0 (n, sqre, d, e, u, ldu, vt, ldvt, smlsiz,
iwork, work, info)
call dlasd0 (n, sqre, d, e, u, ldu, vt, ldvt, smlsiz,
iwork, work, info)
call slasd1 (nl, nr, sqre, d, alpha, beta, u, ldu, vt,
ldvt, idxq, iwork, work, info)
call dlasd1 (nl, nr, sqre, d, alpha, beta, u, ldu, vt,
ldvt, idxq, iwork, work, info)
call slasd2 (nl, nr, sqre, k, d, z, alpha, beta, u, ldu, vt,
ldvt, dsigma, u2, ldu2, vt2, ldvt2, idxp, idx, idxc, idxq, coltyp, info)
call dlasd2 (nl, nr, sqre, k, d, z, alpha, beta, u, ldu, vt,
ldvt, dsigma, u2, ldu2, vt2, ldvt2, idxp, idx, idxc, idxq, coltyp, info)
call slasd3 (nl, nr, sqre, k, d, q, ldq, dsigma, u, ldu, u2, ldu2, vt, ldvt, vt2, ldvt2, idxc, ctot, z, info)
call dlasd3 (nl, nr, sqre, k, d, q, ldq, dsigma, u, ldu, u2, ldu2, vt, ldvt, vt2, ldvt2, idxc, ctot, z, info)
i
-th updated eigenvalue of a positive symmetric rank-1 modification to a positive diagonal matrix. Used by ?bdsdc.
call slasd4 (n, i, d, z, delta, rho, sigma, work, info)
call dlasd4 (n, i, d, z, delta, rho, sigma, work, info)
i
-th eigenvalue of a positive symmetric rank-1 modification of a 2-by-2 diagonal matrix. Used by ?bdsdc.
call slasd5 (i, d, z, delta, rho, dsigma, work)
call dlasd5 (i, d, z, delta, rho, dsigma, work)
call slasd6 (icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info)
call dlasd6 (icompq, nl, nr, sqre, d, vf, vl, alpha, beta, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, poles, difl, difr, z, k, c, s, work, iwork, info)
call slasd7 (icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info)
call dlasd7 (icompq, nl, nr, sqre, k, d, z, zw, vf, vfw, vl, vlw, alpha, beta, dsigma, idx, idxp, idxq, perm, givptr, givcol, ldgcol, givnum, ldgnum, c, s, info)
call slasd8 (icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info)
call dlasd8 (icompq, k, d, z, vf, vl, difl, difr, lddifr, dsigma, work, info)
call slasd9 (icompq, ldu, k, d, z, vf, vl, difl, difr, dsigma, work, info)
call dlasd9 (icompq, ldu, k, d, z, vf, vl, difl, difr, dsigma, work, info)
d
and off-diagonal e
. Used by ?bdsdc.
call slasda (icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)
call dlasda (icompq, smlsiz, n, sqre, d, e, u, ldu, vt, k, difl, difr, z, poles, givptr, givcol, ldgcol, perm, givnum, c, s, work, iwork, info)
d
and off-diagonal e
. Used by ?bdsdc.
call slasdq (uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)
call dlasdq (uplo, sqre, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info)
call slasdt (n, lvl, nd, inode, ndiml, ndimr, msub)
call dlasdt (n, lvl, nd, inode, ndiml, ndimr, msub)
call slaset (uplo, m, n, alpha, beta, a, lda)
call dlaset (uplo, m, n, alpha, beta, a, lda)
call claset (uplo, m, n, alpha, beta, a, lda)
call zlaset (uplo, m, n, alpha, beta, a, lda)
call slasq1 (n, d, e, work, info)
call dlasq1 (n, d, e, work, info)
z
to high relative accuracy. Used by ?bdsqr and ?stegr.
call slasq2 (n, z, info)
call dlasq2 (n, z, info)
call slasq3 (i0, n0, z, pp, dmin, sigma, desig, qmax, nfail, iter, ndiv, ieee)
call dlasq3 (i0, n0, z, pp, dmin, sigma, desig, qmax, nfail, iter, ndiv, ieee)
call slasq4 (i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype)
call dlasq4 (i0, n0, z, pp, n0in, dmin, dmin1, dmin2, dn, dn1, dn2, tau, ttype)
call slasq5 (i0, n0, z, pp, tau, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee)
call dlasq5 (i0, n0, z, pp, tau, dmin, dmin1, dmin2, dn, dnm1, dnm2, ieee)
call slasq6 (i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2)
call dlasq6 (i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2)
call slasr (side, pivot, direct, m, n, c, s, a, lda)
call dlasr (side, pivot, direct, m, n, c, s, a, lda)
call clasr (side, pivot, direct, m, n, c, s, a, lda)
call zlasr (side, pivot, direct, m, n, c, s, a, lda)
call slasrt (id, n, d, info)
call dlasrt (id, n, d, info)
call slassq (n, x, incx, scale, sumsq)
call dlassq (n, x, incx, scale, sumsq)
call classq (n, x, incx, scale, sumsq)
call zlassq (n, x, incx, scale, sumsq)
call slasv2 (f, g, h, ssmin, ssmax, snr, csr, snl, csl)
call dlasv2 (f, g, h, ssmin, ssmax, snr, csr, snl, csl)
call slaswp (n, a, lda, k1, k2, ipiv, incx)
call dlaswp (n, a, lda, k1, k2, ipiv, incx)
call claswp (n, a, lda, k1, k2, ipiv, incx)
call zlaswp (n, a, lda, k1, k2, ipiv, incx)
call slasy2 (ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, xnorm, info)
call dlasy2 (ltranl, ltranr, isgn, n1, n2, tl, ldtl, tr, ldtr, b, ldb, scale, x, ldx, xnorm, info)
call slasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
call dlasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
call clasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
call zlasyf (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
call clahef (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
call zlahef (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info)
call slatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
call dlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
call clatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
call zlatbs (uplo, trans, diag, normin, n, kd, ab, ldab, x, scale, cnorm, info)
n
-by-n
matrix computed by
?getc2 and computes a contribution to the reciprocal Dif-estimate.
call slatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
call dlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
call clatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
call zlatdf (ijob, n, z, ldz, rhs, rdsum, rdscal, ipiv, jpiv)
call slatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
call dlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
call clatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
call zlatps (uplo, trans, diag, normin, n, ap, x, scale, cnorm, info)
nb
rows and columns of a symmetric/Hermitian matrix A to real tridiagonal form by an orthogonal/unitary similarity transformation.
call slatrd (uplo, n, nb, a, lda, e, tau, w, ldw)
call dlatrd (uplo, n, nb, a, lda, e, tau, w, ldw)
call clatrd (uplo, n, nb, a, lda, e, tau, w, ldw)
call zlatrd (uplo, n, nb, a, lda, e, tau, w, ldw)
call slatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
call dlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
call clatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
call zlatrs (uplo, trans, diag, normin, n, a, lda, x, scale, cnorm, info)
call slatrz (m, n, l, a, lda, tau, work)
call dlatrz (m, n, l, a, lda, tau, work)
call clatrz (m, n, l, a, lda, tau, work)
call zlatrz (m, n, l, a, lda, tau, work)
call slauu2 (uplo, n, a, lda, info)
call dlauu2 (uplo, n, a, lda, info)
call clauu2 (uplo, n, a, lda, info)
call zlauu2 (uplo, n, a, lda, info)
call slauum (uplo, n, a, lda, info)
call dlauum (uplo, n, a, lda, info)
call clauum (uplo, n, a, lda, info)
call zlauum (uplo, n, a, lda, info)
call sorg2l (m, n, k, a, lda, tau, work, info)
call dorg2l (m, n, k, a, lda, tau, work, info)
call cung2l (m, n, k, a, lda, tau, work, info)
call zung2l (m, n, k, a, lda, tau, work, info)
call sorg2r (m, n, k, a, lda, tau, work, info)
call dorg2r (m, n, k, a, lda, tau, work, info)
call cung2r (m, n, k, a, lda, tau, work, info)
call zung2r (m, n, k, a, lda, tau, work, info)
call sorgl2 (m, n, k, a, lda, tau, work, info)
call dorgl2 (m, n, k, a, lda, tau, work, info)
call cungl2 (m, n, k, a, lda, tau, work, info)
call zungl2 (m, n, k, a, lda, tau, work, info)
call sorgr2 (m, n, k, a, lda, tau, work, info)
call dorgr2 (m, n, k, a, lda, tau, work, info)
call cungr2 (m, n, k, a, lda, tau, work, info)
call zungr2 (m, n, k, a, lda, tau, work, info)
call sorm2l (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call dorm2l (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call cunm2l (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call zunm2l (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call sorm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call dorm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call cunm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call zunm2r (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call sorml2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call dorml2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call cunml2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call zunml2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call sormr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call dormr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call cunmr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call zunmr2 (side, trans, m, n, k, a, lda, tau, c, ldc, work, info)
call sormr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info)
call dormr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info)
call cunmr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info)
call zunmr3 (side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info)
call spbtf2 (uplo, n, kd, ab, ldab, info)
call dpbtf2 (uplo, n, kd, ab, ldab, info)
call cpbtf2 (uplo, n, kd, ab, ldab, info)
call zpbtf2 (uplo, n, kd, ab, ldab, info)
call spotf2 (uplo, n, a, lda, info)
call dpotf2 (uplo, n, a, lda, info)
call cpotf2 (uplo, n, a, lda, info)
call zpotf2 (uplo, n, a, lda, info)
call sptts2 (n, nrhs, d, e, b, ldb)
call dptts2 (n, nrhs, d, e, b, ldb)
call cptts2 (iuplo, n, nrhs, d, e, b, ldb)
call zptts2 (iuplo, n, nrhs, d, e, b, ldb)
call srscl (n, sa, sx, incx)
call drscl (n, sa, sx, incx)
call csrscl (n, sa, sx, incx)
call zdrscl (n, sa, sx, incx)
call ssygs2 (itype, uplo, n, a, lda, b, ldb, info)
call dsygs2 (itype, uplo, n, a, lda, b, ldb, info)
call chegs2 (itype, uplo, n, a, lda, b, ldb, info)
call zhegs2 (itype, uplo, n, a, lda, b, ldb, info)
call ssytd2 (uplo, n, a, lda, d, e, tau, info)
call dsytd2 (uplo, n, a, lda, d, e, tau, info)
call chetd2 (uplo, n, a, lda, d, e, tau, info)
call zhetd2 (uplo, n, a, lda, d, e, tau, info)
call ssytf2 (uplo, n, a, lda, ipiv, info)
call dsytf2 (uplo, n, a, lda, ipiv, info)
call csytf2 (uplo, n, a, lda, ipiv, info)
call zsytf2 (uplo, n, a, lda, ipiv, info)
call chetf2 (uplo, n, a, lda, ipiv, info)
call zhetf2 (uplo, n, a, lda, ipiv, info)
call stgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, info)
call dtgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, n1, n2, work, lwork, info)
call ctgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info)
call ztgex2 (wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, j1, info)
call stgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, iwork, pq, info)
call dtgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, iwork, pq, info)
call ctgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info)
call ztgsy2 (trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, rdsum, rdscal, info)
call strti2 (uplo, diag, n, a, lda, info)
call dtrti2 (uplo, diag, n, a, lda, info)
call ctrti2 (uplo, diag, n, a, lda, info)
call ztrti2 (uplo, diag, n, a, lda, info)
call xerbla (srname, info)
* Legal Information © 1999, 2002-2004, Intel Corporation