### LAPACK Auxiliary Routines

?lacgv conjugates a complex vector.
``` call clacgv (n, x, incx) call zlacgv (n, x, incx) ```

?lacrm multiplies a complex matrix by a square real matrix.
``` call clacrm (m, n, a, lda, b, ldb, c, ldc, rwork) call zlacrm (m, n, a, lda, b, ldb, c, ldc, rwork) ```

?lacrt performs a linear transformation of a pair of complex vectors.
``` call clacrt (n, cx, incx, cy, incy, c, s) call zlacrt (n, cx, incx, cy, incy, c, s) ```

?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.
``` call claesy (a, b, c, rt1, rt2, evscal, cs1, sn1) call zlaesy (a, b, c, rt1, rt2, evscal, cs1, sn1) ```

?rot applies a plane rotation with real cosine and complex sine to a pair of complex vectors.
``` call crot (n, cx, incx, cy, incy, c, s) call zrot (n, cx, incx, cy, incy, c, s) ```

?spmv computes a matrix-vector product for complex vectors using a complex symmetric packed matrix.
``` call cspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) call zspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) ```

?spr performs the symmetrical rank-1 update of a complex symmetric packed matrix.
``` call cspr (uplo, n, alpha, x, incx, ap) call zspr (uplo, n, alpha, x, incx, ap) ```

?symv computes a matrix-vector product for a complex symmetric matrix.
``` call csymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) call zsymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) ```

?syr performs the symmetric rank-1 update of a complex symmetric matrix.
``` call csyr (uplo, n, alpha, x, incx, a, lda) call zsyr (uplo, n, alpha, x, incx, a, lda) ```

i?max1 finds the index of the vector element whose real part has maximum absolute value.
``` index = icmax1 (n, cx, incx) index = izmax1 (n, cx, incx) ```

ilaenv is an environmental enquiry function that returns values for tuning algorithmic performance.
``` value = ilaenv (ispec, name, opts, n1, n2, n3, n4) ```

lsame tests two characters for equality regardless of case.
``` val = lsame (ca, cb) ```

lsamen tests two character strings for equality regardless of case.
``` val = lsamen (n, ca, cb) ```

?sum1 forms the 1-norm of the complex vector using the true absolute value.
``` res = scsum1 (n, cx, incx) res = dzsum1 (n, cx, incx) ```

?gbtf2 computes the LU factorization of a general band matrix using the unblocked version of the algorithm.
``` 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) ```

?gebd2 reduces a general matrix to bidiagonal form using an unblocked algorithm.
``` 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) ```

?gehd2 reduces a general square matrix to upper Hessenberg form using an unblocked algorithm.
``` 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) ```

?gelq2 computes the LQ factorization of a general rectangular matrix using an unblocked algorithm.
``` 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) ```

?geql2 computes the QL factorization of a general rectangular matrix using an unblocked algorithm.
``` 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) ```

?geqr2 computes the QR factorization of a general rectangular matrix using an unblocked algorithm.
``` 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) ```

?gerq2 computes the RQ factorization of a general rectangular matrix using an unblocked algorithm.
``` 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) ```

?gesc2 solves a system of linear equations using the LU factorization with complete pivoting computed by ?getc2.
``` 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) ```

?getc2 computes the LU factorization with complete pivoting of the general `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) ```

?getf2 computes the LU factorization of a general `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) ```

?gtts2 solves a system of linear equations with a tridiagonal matrix using the LU factorization computed by ?gttrf.
``` 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) ```

?labad returns the square root of the underflow and overflow thresholds, if the exponent-range is very large.
``` call slabad (small, large) call dlabad (small, large) ```

?labrd reduces the first `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) ```

?lacon estimates the 1-norm of a square matrix, using reverse communication for evaluating matrix-vector products.
``` call slacon (n, v, x, isgn, est, kase, jmax, jump, iter) call dlacon (n, v, x, isgn, est, kase, jmax, jump, iter) call clacon (n, v, x, est, kase, jmax, jump, iter) call zlacon (n, v, x, est, kase, jmax, jump, iter) ```

?lacpy copies all or part of one two-dimensional array to another.
``` 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) ```

?ladiv performs complex division in real arithmetic, avoiding unnecessary overflow.
``` call sladiv (a, b, c, d, p, q) call dladiv (a, b, c, d, p, q) res = cladiv (x, y) res = zladiv (x, y) ```

?lae2 computes the eigenvalues of a 2-by-2 symmetric matrix.
``` call slae2 (a, b, c, rt1, rt2) call dlae2 (a, b, c, rt1, rt2) ```

?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.
``` 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) ```

?laed0 is used by ?stedc. Computes all eigenvalues and corresponding eigenvectors of an unreduced symmetric tridiagonal matrix using the divide and conquer method.
``` 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) ```

?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.
``` call slaed1 (n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info) call dlaed1 (n, d, q, ldq, indxq, rho, cutpnt, work, iwork, info) ```

?laed2 is used by sstedc/dstedc. Merges eigenvalues and deflates secular equation. Used when the original matrix is tridiagonal.
``` 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) ```

?laed3 is used by sstedc/dstedc. Finds the roots of the secular equation and updates the eigenvectors. Used when the original matrix is tridiagonal.
``` 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) ```

?laed4 is used by sstedc/dstedc. Finds a single root of the secular equation.
``` call slaed4 (n, i, d, z, delta, rho, dlam, info) call dlaed4 (n, i, d, z, delta, rho, dlam, info) ```

?laed5 is used by sstedc/dstedc. Solves the 2-by-2 secular equation.
``` call slaed5 (i, d, z, delta, rho, dlam) call dlaed5 (i, d, z, delta, rho, dlam) ```

?laed6 is used by sstedc/dstedc. Computes one Newton step in solution of the secular equation.
``` call slaed6 (kniter, orgati, rho, d, z, finit, tau, info) call dlaed6 (kniter, orgati, rho, d, z, finit, tau, info) ```

?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.
``` 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) ```

?laed8 is used by ?stedc. Merges eigenvalues and deflates secular equation. Used when the original matrix is dense.
``` 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) ```

?laed9 is used by sstedc/dstedc. Finds the roots of the secular equation and updates the eigenvectors. Used when the original matrix is dense.
``` 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) ```

?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.
``` 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) ```

?laein computes a specified right or left eigenvector of an upper Hessenberg matrix by inverse iteration.
``` 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) ```

?laev2 computes the eigenvalues and eigenvectors of a 2-by-2 symmetric/Hermitian matrix.
``` 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) ```

?laexc swaps adjacent diagonal blocks of a real upper quasi-triangular matrix in Schur canonical form by an orthogonal similarity transformation.
``` 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) ```

?lag2 computes the eigenvalues of a 2-by-2 generalized eigenvalue problem, with scaling as necessary to avoid over-/underflow.
``` call slag2 (a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) call dlag2 (a, lda, b, ldb, safmin, scale1, scale2, wr1, wr2, wi) ```

?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.
``` 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) ```

?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.
``` call slagtf (n, a, lambda, b, c, tol, d, in, info) call dlagtf (n, a, lambda, b, c, tol, d, in, info) ```

?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.
``` 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) ```

?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.
``` call slagts (job, n, a, b, c, d, in, y, tol, info) call dlagts (job, n, a, b, c, d, in, y, tol, info) ```

?lagv2 computes the Generalized Schur factorization of a real 2-by-2 matrix pencil (A,B), where B is the upper triangular.
``` 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) ```

?lahqr computes the eigenvalues and Schur factorization of an upper Hessenberg matrix, using the double-shift/single-shift QR algorithm.
``` 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) ```

?lahrd reduces the first `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) ```

?laic1 applies one step of incremental condition estimation.
``` 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) ```

?laln2 solves a 1-by-1 or 2-by-2 linear system of equations of the specified form.
``` 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) ```

?lals0 applies back multiplying factors in solving the least squares problem using the divide and conquer SVD approach. Used by ?gelsd.
``` 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) ```

?lalsa computes the SVD of the coefficient matrix in compact form. Used by ?gelsd.
``` 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) ```

?lalsd uses the singular value decomposition of A to solve the least squares problem.
``` 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) ```

?lamch determines machine parameters for floating-point arithmetic.
``` val = slamch (cmach) val = dlamch (cmach) ```

?lamc1 is called from ?lamc2. Determines machine parameters given by `beta, t, rnd, ieeel`.
``` call slamc1 (beta, t, rnd, ieeel) call dlamc1 (beta, t, rnd, ieeel) ```

?lamc2 is used by ?lamch. Determines machine parameters specified in its arguments list.
``` call slamc2 (beta, t, rnd, eps, emin, rmin, emax, rmax) call dlamc2 (beta, t, rnd, eps, emin, rmin, emax, rmax) ```

?lamc3 is called from ?lamc1-?lamc5. Intended to force `a` and `b` to be stored prior to doing the addition of `a` and `b`.
``` val = slamc3 (a, b) val = dlamc3 (a, b) ```

?lamc4 is a service routine for ?lamc2.
``` call slamc4 (emin, start, base) call dlamc4 (emin, start, base) ```

?lamc5 is called from ?lamc2. Attempts to compute the largest machine floating-point number, without overflow.
``` call slamc5 (beta, p, emin, ieee, emax, rmax) call dlamc5 (beta, p, emin, ieee, emax, rmax) ```

?lamrg creates a permutation list to merge the entries of two independently sorted sets into a single set sorted in acsending order.
``` call slamrg (n1, n2, a, strd1, strd2, index) call dlamrg (n1, n2, a, strd1, strd2, index) ```

?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.
``` 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) ```

?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.
``` 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) ```

?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.
``` 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) ```

?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.
``` 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) ```

?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.
``` 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) ```

?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.
``` val = clanhb (norm, uplo, n, k, ab, ldab, work) val = zlanhb (norm, uplo, n, k, ab, ldab, work) ```

?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.
``` 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) ```

?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.
``` val = clanhp (norm, uplo, n, ap, work) val = zlanhp (norm, uplo, n, ap, work) ```

?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.
``` val = slanst (norm, n, d, e) val = dlanst (norm, n, d, e) val = clanht (norm, n, d, e) val = zlanht (norm, n, d, e) ```

?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.
``` 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) ```

?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.
``` val = clanhe (norm, uplo, n, a, lda, work) val = zlanhe (norm, uplo, n, a, lda, work) ```

?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.
``` 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) ```

?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.
``` 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) ```

?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.
``` 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) ```

?lanv2 computes the Schur factorization of a real 2-by-2 nonsymmetric matrix in standard form.
``` call slanv2 (a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) call dlanv2 (a, b, c, d, rt1r, rt1i, rt2r, rt2i, cs, sn) ```

?lapll measures the linear dependence of two vectors.
``` 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) ```

?lapmt performs a forward or backward permutation of the columns of a matrix.
``` 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) ```

?lapy2 returns sqrt(`x`2 +`y`2).
``` val = slapy2 (x, y) val = dlapy2 (x, y) ```

?lapy3 returns sqrt(`x`2+`y`2+`z`2).
``` val = slapy3 (x, y, z) val = dlapy3 (x, y, z) ```

?laqgb scales a general band matrix, using row and column scaling factors computed by ?gbequ.
``` 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) ```

?laqge scales a general rectangular matrix, using row and column scaling factors computed by ?geequ.
``` 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) ```

?laqp2 computes a QR factorization with column pivoting of the matrix block.
``` 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) ```

?laqps computes a step of QR factorization with column pivoting of a real `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) ```

?laqsb scales a symmetric/Hermitian band matrix, using scaling factors computed by ?pbequ.
``` 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) ```

?laqsp scales a symmetric/Hermitian matrix in packed storage, using scaling factors computed by ?ppequ.
``` 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) ```

?laqsy scales a symmetric/Hermitian matrix, using scaling factors computed by ?poequ.
``` 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) ```

?laqtr solves a real quasi-triangular system of equations, or a complex quasi-triangular system of special form, in real arithmetic.
``` 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) ```

?lar1v computes the (scaled) `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) ```

?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.
``` 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) ```

?larf applies an elementary reflector to a general rectangular matrix.
``` 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) ```

?larfb applies a block reflector or its transpose/conjugate-transpose to a general rectangular matrix.
``` 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) ```

?larfg generates an elementary reflector (Householder matrix).
``` 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) ```

?larft forms the triangular factor T of a block reflector H = I - VTVH.
``` 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) ```

?larfx applies an elementary reflector to a general rectangular matrix, with loop unrolling when the reflector has order Ј 10.
``` 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) ```

?largv generates a vector of plane rotations with real cosines and real/complex sines.
``` 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) ```

?larnv returns a vector of random numbers from a uniform or normal distribution.
``` call slarnv (idist, iseed, n, x) call dlarnv (idist, iseed, n, x) call clarnv (idist, iseed, n, x) call zlarnv (idist, iseed, n, x) ```

?larrb provides limited bisection to locate eigenvalues for more accuracy.
``` 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) ```

?larre sets small off-diagonal elements of the tridiagonal matrix T to zero and finds base representations and eigenvalues for each unreduced block Ti .
``` 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) ```

?larrf finds a new relatively robust representation such that at least one of the eigenvalues is relatively isolated.
``` 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) ```

?larrv computes the eigenvectors of the tridiagonal matrix T = L D LT given L, D, and the eigenvalues of L D LT.
``` 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) ```

?lartg generates a plane rotation with real cosine and real/complex sine.
``` 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) ```

?lartv applies a vector of plane rotations with real cosines and real/complex sines to the elements of a pair of vectors.
``` 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) ```

?laruv returns a vector of `n` random real numbers from a uniform distribution.
``` call slaruv (iseed, n, x) call dlaruv (iseed, n, x) ```

?larz applies an elementary reflector (as returned by ?tzrzf) to a general matrix.
``` 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) ```

?larzb applies a block reflector or its transpose/conjugate-transpose to a general matrix.
``` 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) ```

?larzt forms the triangular factor T of a block reflector H = I - VTVH.
``` 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) ```

?las2 computes singular values of a 2-by-2 triangular matrix.
``` call slas2 (f, g, h, ssmin, ssmax) call dlas2 (f, g, h, ssmin, ssmax) ```

?lascl multiplies a general rectangular matrix by a real scalar defined as `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) ```

?lasd0 computes the singular values of a real upper bidiagonal `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) ```

?lasd1 computes the SVD of an upper bidiagonal matrix B of the specified size. Used by ?bdsdc.
``` 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) ```

?lasd2 merges the two sets of singular values together into a single sorted set. Used by ?bdsdc.
``` 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) ```

?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.
``` 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) ```

?lasd4 computes the square root of the `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) ```

?lasd5 computes the square root of the `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) ```

?lasd6 computes the SVD of an updated upper bidiagonal matrix obtained by merging two smaller ones by appending a row. Used by ?bdsdc.
``` 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) ```

?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.
``` 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) ```

?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.
``` 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) ```

?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.
``` 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) ```

?lasda computes the SVD of a real upper bidiagonal matrix with diagonal `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) ```

?lasdq computes the SVD of a real bidiagonal matrix with diagonal `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) ```

?lasdt creates a tree of subproblems for bidiagonal divide and conquer. Used by ?bdsdc.
``` call slasdt (n, lvl, nd, inode, ndiml, ndimr, msub) call dlasdt (n, lvl, nd, inode, ndiml, ndimr, msub) ```

?laset initializes the off-diagonal elements and the diagonal elements of a matrix to given values.
``` 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) ```

?lasq1 computes the singular values of a real square bidiagonal matrix. Used by ?bdsqr.
``` call slasq1 (n, d, e, work, info) call dlasq1 (n, d, e, work, info) ```

?lasq2 computes all the eigenvalues of the symmetric positive definite tridiagonal matrix associated with the qd array `z` to high relative accuracy. Used by ?bdsqr and ?stegr.
``` call slasq2 (n, z, info) call dlasq2 (n, z, info) ```

?lasq3 checks for deflation, computes a shift, and calls dqds. Used by ?bdsqr.
``` 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) ```

?lasq4 computes an approximation to the smallest eigenvalue using values of d from the previous transform. Used by ?bdsqr.
``` 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) ```

?lasq5 computes one dqds transform in ping-pong form. Used by ?bdsqr and ?stegr.
``` 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) ```

?lasq6 computes one dqds transform in ping-pong form. Used by ?bdsqr and ?stegr.
``` call slasq6 (i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2) call dlasq6 (i0, n0, z, pp, dmin, dmin1, dmin2, dn, dnm1, dnm2) ```

?lasr applies a sequence of plane rotations to a general rectangular matrix.
``` 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) ```

?lasrt sorts numbers in increasing or decreasing order.
``` call slasrt (id, n, d, info) call dlasrt (id, n, d, info) ```

?lassq updates a sum of squares represented in scaled form.
``` 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) ```

?lasv2 computes the SVD of a 2-by-2 triangular matrix.
``` call slasv2 (f, g, h, ssmin, ssmax, snr, csr, snl, csl) call dlasv2 (f, g, h, ssmin, ssmax, snr, csr, snl, csl) ```

?laswp performs a series of row interchanges on a general rectangular matrix.
``` 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) ```

?lasy2 solves the Sylvester matrix equation, where the matrices are of order 1 or 2.
``` 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) ```

?lasyf computes a partial factorization of a real/complex symmetric matrix, using the diagonal pivoting method.
``` 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) ```

?lahef computes a partial factorization of a complex Hermitian indefinite matrix, using the diagonal pivoting method.
``` call clahef (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) call zlahef (uplo, n, nb, kb, a, lda, ipiv, w, ldw, info) ```

?latbs solves a triangular banded system of equations.
``` 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) ```

?latdf uses the LU factorization of the `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) ```

?latps solves a triangular system of equations with the matrix held in packed storage.
``` 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) ```

?latrd reduces the first `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) ```

?latrs solves a triangular system of equations with the scale factor set to prevent overflow.
``` 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) ```

?latrz factors an upper trapezoidal matrix by means of orthogonal/unitary transformations.
``` 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) ```

?lauu2 computes the product U U H or LH L, where U and L are upper or lower triangular matrices (unblocked algorithm).
``` 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) ```

?lauum computes the product U U H or LH L, where U and L are upper or lower triangular matrices.
``` 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) ```

?org2l/?ung2l generates all or part of the orthogonal/unitary matrix Q from a QL factorization determined by ?geqlf (unblocked algorithm).
``` 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) ```

?org2r/?ung2r generates all or part of the orthogonal/unitary matrix Q from a QR factorization determined by ?geqrf (unblocked algorithm).
``` 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) ```

?orgl2/?ungl2 generates all or part of the orthogonal/unitary matrix Q from an LQ factorization determined by ?gelqf (unblocked algorithm).
``` 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) ```

?orgr2/?ungr2 generates all or part of the orthogonal/unitary matrix Q from an RQ factorization determined by ?gerqf (unblocked algorithm).
``` 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) ```

?orm2l/?unm2l multiplies a general matrix by the orthogonal/unitary matrix from a QL factorization determined by ?geqlf (unblocked algorithm).
``` 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) ```

?orm2r/?unm2r multiplies a general matrix by the orthogonal/unitary matrix from a QR factorization determined by ?geqrf (unblocked algorithm).
``` 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) ```

?orml2/?unml2 multiplies a general matrix by the orthogonal/unitary matrix from an LQ factorization determined by ?gelqf (unblocked algorithm).
``` 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) ```

?ormr2/?unmr2 multiplies a general matrix by the orthogonal/unitary matrix from an RQ factorization determined by ?gerqf (unblocked algorithm).
``` 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) ```

?ormr3/?unmr3 multiplies a general matrix by the orthogonal/unitary matrix from an RZ factorization determined by ?tzrzf (unblocked algorithm).
``` 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) ```

?pbtf2 computes the Cholesky factorization of a symmetric/Hermitian positive definite band matrix (unblocked algorithm).
``` 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) ```

?potf2 computes the Cholesky factorization of a symmetric/Hermitian positive definite matrix (unblocked algorithm).
``` 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) ```

?ptts2 solves a tridiagonal system of the form AX=B using the L D LH factorization computed by ?pttrf.
``` 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) ```

?rscl multiplies a vector by the reciprocal of a real scalar.
``` call srscl (n, sa, sx, incx) call drscl (n, sa, sx, incx) call csrscl (n, sa, sx, incx) call zdrscl (n, sa, sx, incx) ```

?sygs2/?hegs2 reduces a symmetric/Hermitian definite generalized eigenproblem to standard form, using the factorization results obtained from ?potrf (unblocked algorithm).
``` 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) ```

?sytd2/?hetd2 reduces a symmetric/Hermitian matrix to real symmetric tridiagonal form by an orthogonal/unitary similarity transformation (unblocked algorithm).
``` 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) ```

?sytf2 computes the factorization of a real/complex symmetric indefinite matrix, using the diagonal pivoting method (unblocked algorithm).
``` 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) ```

?hetf2 computes the factorization of a complex Hermitian matrix, using the diagonal pivoting method (unblocked algorithm).
``` call chetf2 (uplo, n, a, lda, ipiv, info) call zhetf2 (uplo, n, a, lda, ipiv, info) ```

?tgex2 swaps adjacent diagonal blocks in an upper (quasi)triangular matrix pair by an orthogonal/unitary equivalence transformation.
``` 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) ```

?tgsy2 solves the generalized Sylvester equation (unblocked algorithm).
``` 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) ```

?trti2 computes the inverse of a triangular matrix (unblocked algorithm).
``` 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) ```

xerbla is an error handling routine called by LAPACK routines.
``` call xerbla (srname, info) ```

* Legal Information © 1999, 2002-2004, Intel Corporation