### ScaLAPACK Auxiliary and Utility Routines

#### Auxiliary Routines

p?lacgv conjugates a complex vector.
``` call pclacgv (n, x, ix, jx, descx, incx) call pzlacgv (n, x, ix, jx, descx, incx) ```

p?max1 finds the index of the element whose real part has maximum absolute value similar to the Level 1 PBLAS `pcamax`, but using the absolute value to the real part.
``` call pcmax1 (n, amax, indx, x, ix, jx, descx, incx) call pzmax1 (n, amax, indx, x, ix, jx, descx, incx) ```

?combamax1 finds the element with maximum real part absolute value and its corresponding global index.
``` call ccombamax1 (v1, v2) call zcombamax1 (v1, v2) ```

p?sum1 forms the 1-norm of a complex vector similar to Level 1 PBLAS `pscasum`, but using the true absolute value.
``` call pscsum1 (n, asum, x, ix, jx, descx, incx) call pdzsum1 (n, asum, x, ix, jx, descx, incx) ```

p?dbtrsv computes an LU factorization of a general tridiagonal matrix with no pivoting. The routine is called by `p?dbtrs`.
``` call psdbtrsv (uplo, trans, n, bwl, bwu, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pddbtrsv (uplo, trans, n, bwl, bwu, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pcdbtrsv (uplo, trans, n, bwl, bwu, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pzdbtrsv (uplo, trans, n, bwl, bwu, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) ```

p?dttrsv computes an LU factorization of a general band matrix, using partial pivoting with row interchanges. The routine is called by `p?dttrs`.
``` call psdttrsv (uplo, trans, n, nrhs, dl, d, du, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pddttrsv (uplo, trans, n, nrhs, dl, d, du, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pcdttrsv (uplo, trans, n, nrhs, dl, d, du, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pzdttrsv (uplo, trans, n, nrhs, dl, d, du, ja, desca, b, ib, descb, af, laf, work, lwork, info) ```

p?gebd2 reduces a general rectangular matrix to real bidiagonal form by an orthogonal/unitary transformation (unblocked algorithm).
``` call psgebd2 (m, n, a, ia, ja, desca, d, e, tauq, taup, work, lwork, info) call pdgebd2 (m, n, a, ia, ja, desca, d, e, tauq, taup, work, lwork, info) call pcgebd2 (m, n, a, ia, ja, desca, d, e, tauq, taup, work, lwork, info) call pzgebd2 (m, n, a, ia, ja, desca, d, e, tauq, taup, work, lwork, info) ```

p?gehd2 reduces a general matrix to upper Hessenberg form by an orthogonal/unitary similarity transformation (unblocked algorithm).
``` call psgehd2 (n, ilo, ihi, a, ia, ja, desca, tau, work, lwork, info) call pdgehd2 (n, ilo, ihi, a, ia, ja, desca, tau, work, lwork, info) call pcgehd2 (n, ilo, ihi, a, ia, ja, desca, tau, work, lwork, info) call pzgehd2 (n, ilo, ihi, a, ia, ja, desca, tau, work, lwork, info) ```

p?gelq2 computes an LQ factorization of a general rectangular matrix (unblocked algorithm).
``` call psgelq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pdgelq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pcgelq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pzgelq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) ```

p?geql2 computes a QL factorization of a general rectangular matrix (unblocked algorithm).
``` call psgeql2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pdgeql2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pcgeql2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pzgeql2 (m, n, a, ia, ja, desca, tau, work, lwork, info) ```

p?geqr2 computes a QR factorization of a general rectangular matrix (unblocked algorithm).
``` call psgeqr2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pdgeqr2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pcgeqr2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pzgeqr2 (m, n, a, ia, ja, desca, tau, work, lwork, info) ```

p?gerq2 computes an RQ factorization of a general rectangular matrix (unblocked algorithm).
``` call psgerq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pdgerq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pcgerq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) call pzgerq2 (m, n, a, ia, ja, desca, tau, work, lwork, info) ```

p?getf2 computes an LU factorization of a general matrix, using partial pivoting with row interchanges (local blocked algorithm).
``` call psgetf2 (m, n, a, ia, ja, desca, ipiv, info) call pdgetf2 (m, n, a, ia, ja, desca, ipiv, info) call pcgetf2 (m, n, a, ia, ja, desca, ipiv, info) call pzgetf2 (m, n, a, ia, ja, desca, ipiv, info) ```

p?labrd reduces the first `nb` rows and columns of a general rectangular matrix A to real bidiagonal form by an orthogonal|unitary transformation, and returns auxiliary matrices that are needed to apply the transformation to the unreduced part of A.
``` call pslabrd (m, n, nb, a, ia, ja, desca, d, e, tauq, taup, x, ix, jx, descx, y, iy, jy, descy, work) call pdlabrd (m, n, nb, a, ia, ja, desca, d, e, tauq, taup, x, ix, jx, descx, y, iy, jy, descy, work) call pclabrd (m, n, nb, a, ia, ja, desca, d, e, tauq, taup, x, ix, jx, descx, y, iy, jy, descy, work) call pzlabrd (m, n, nb, a, ia, ja, desca, d, e, tauq, taup, x, ix, jx, descx, y, iy, jy, descy, work) ```

p?lacon estimates the 1-norm of a square matrix, using the reverse communication for evaluating matrix-vector products.
``` call pslacon (n, v, iv, jv, descv, x, ix, jx, descx, isgn, est, kase) call pdlacon (n, v, iv, jv, descv, x, ix, jx, descx, isgn, est, kase) call pclacon (n, v, iv, jv, descv, x, ix, jx, descx, isgn, est, kase) call pzlacon (n, v, iv, jv, descv, x, ix, jx, descx, isgn, est, kase) ```

p?laconsb looks for two consecutive small subdiagonal elements.
``` call pslaconsb (a, desca, i, l, m, h44, h33, h43h34, buf, lwork) call pdlaconsb (a, desca, i, l, m, h44, h33, h43h34, buf, lwork) ```

p?lacp2 copies all or part of a distributed matrix to another distributed matrix.
``` call pslacp2 (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) call pdlacp2 (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) call pclacp2 (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) call pzlacp2 (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) ```

p?lacp3 copies from a global parallel array into a local replicated array or vice versa.
``` call pslacp3 (m, i, a, desca, b, ldb, ii, jj, rev) call pdlacp3 (m, i, a, desca, b, ldb, ii, jj, rev) ```

p?lacpy copies all or part of one two-dimensional array to another.
``` call pslacpy (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) call pdlacpy (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) call pclacpy (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) call pzlacpy (uplo, m, n, a, ia, ja, desca, b, ib, jb, descb) ```

p?laevswp moves the eigenvectors from where they are computed to ScaLAPACK standard block cyclic array.
``` call pslaevswp (n, zin, ldzi, z, iz, jz, descz, nvs, key, rwork, lrwork) call pdlaevswp (n, zin, ldzi, z, iz, jz, descz, nvs, key, rwork, lrwork) call pclaevswp (n, zin, ldzi, z, iz, jz, descz, nvs, key, rwork, lrwork) call pzlaevswp (n, zin, ldzi, z, iz, jz, descz, nvs, key, rwork, lrwork) ```

p?lahrd reduces the first `nb` columns of a general rectangular matrix A so that elements below the `k`th subdiagonal are zero, by anorthogonal/unitary transformation, and returns auxiliary matrices which are needed to apply the transformation to the unreduced part of A.
``` call pslahrd (n, k, nb, a, ia, ja, desca, tau, t, y, iy, jy, descy, work) call pdlahrd (n, k, nb, a, ia, ja, desca, tau, t, y, iy, jy, descy, work) call pclahrd (n, k, nb, a, ia, ja, desca, tau, t, y, iy, jy, descy, work) call pzlahrd (n, k, nb, a, ia, ja, desca, tau, t, y, iy, jy, descy, work) ```

p?laiect exploits IEEE arithmetic to accelerate the computations of eigenvalues (C interface function).
``` void pslaiect (float *sigma, int *n, float *d, int *count); void pdlaiectb (float *sigma, int *n, float *d, int *count); void pdlaiectl (float *sigma, int *n, float *d, int *count); ```

p?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 = pslange (norm, m, n, a, ia, ja, desca, work) val = pdlange (norm, m, n, a, ia, ja, desca, work) val = pclange (norm, m, n, a, ia, ja, desca, work) val = pzlange (norm, m, n, a, ia, ja, desca, work) ```

p?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 = pslanhs (norm, n, a, ia, ja, desca, work) val = pdlanhs (norm, n, a, ia, ja, desca, work) val = pclanhs (norm, n, a, ia, ja, desca, work) val = pzlanhs (norm, n, a, ia, ja, desca, work) ```

p?lansy/p?lanhe returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a real/complex symmetric/Hermitian matrix.
``` val = pslansy (norm, uplo, n, a, ia, ja, desca, work) val = pdlansy (norm, uplo, n, a, ia, ja, desca, work) val = pclansy (norm, uplo, n, a, ia, ja, desca, work) val = pzlansy (norm, uplo, n, a, ia, ja, desca, work) val = pclanhe (norm, uplo, n, a, ia, ja, desca, work) val = pzlanhe (norm, uplo, n, a, ia, ja, desca, work) ```

p?lantr returns the value of the 1-norm, Frobenius norm, infinity-norm, or the largest absolute value of any element of a triangular matrix.
``` val = pslantr (norm, uplo, diag, m, n, a, ia, ja, desca, work) val = pdlantr (norm, uplo, diag, m, n, a, ia, ja, desca, work) val = pclantr (norm, uplo, diag, m, n, a, ia, ja, desca, work) val = pzlantr (norm, uplo, diag, m, n, a, ia, ja, desca, work) ```

p?lapiv applies a permutation matrix to a general distributed matrix, resulting in row or column pivoting.
``` call pslapiv (direc, rowcol, pivroc, m, n, a, ia, ja, desca, ipiv, ip, jp, descip, iwork) call pdlapiv (direc, rowcol, pivroc, m, n, a, ia, ja, desca, ipiv, ip, jp, descip, iwork) call pclapiv (direc, rowcol, pivroc, m, n, a, ia, ja, desca, ipiv, ip, jp, descip, iwork) call pzlapiv (direc, rowcol, pivroc, m, n, a, ia, ja, desca, ipiv, ip, jp, descip, iwork) ```

p?laqge scales a general rectangular matrix, using row and column scaling factors computed by `p?geequ`.
``` call pslaqge (m, n, a, ia, ja, desca, r, c, rowcnd, colcnd, amax, equed) call pdlaqge (m, n, a, ia, ja, desca, r, c, rowcnd, colcnd, amax, equed) call pclaqge (m, n, a, ia, ja, desca, r, c, rowcnd, colcnd, amax, equed) call pzlaqge (m, n, a, ia, ja, desca, r, c, rowcnd, colcnd, amax, equed) ```

p?laqsy scales a general rectangular matrix, using row and column scaling factors computed by `p?poequ`.
``` call pslaqsy (uplo, n, a, ia, ja, desca, sr, sc, scond, amax, equed) call pdlaqsy (uplo, n, a, ia, ja, desca, sr, sc, scond, amax, equed) call pclaqsy (uplo, n, a, ia, ja, desca, sr, sc, scond, amax, equed) call pzlaqsy (uplo, n, a, ia, ja, desca, sr, sc, scond, amax, equed) ```

p?lared1d redistributes an array assuming that the input array `bycol` is distributed across rows and that all process columns contain the same copy of ``` bycol```.
``` call pslared1d (n, ia, ja, desc, bycol, byall, work, lwork) call pdlared1d (n, ia, ja, desc, bycol, byall, work, lwork) ```

p?lared2d redistributes an array assuming that the input array `byrow` is distributed across columns and that all process rows contain the same copy of ``` byrow```. The output array byall will be identical on all processes.
``` call pslared2d (n, ia, ja, desc, byrow, byall, work, lwork) call pdlared2d (n, ia, ja, desc, byrow, byall, work, lwork) ```

p?larf applies an elementary reflector to a general rectangular matrix.
``` call pslarf (side, m, n, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pdlarf (side, m, n, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pclarf (side, m, n, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pzlarf (side, m, n, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) ```

p?larfb applies a block reflector or its transpose/conjugate-transpose to a general rectangular matrix.
``` call pslarfb (side, trans, direct, storev, m, n, k, v, iv, jv, descv, t, c, ic, jc, descc, work) call pdlarfb (side, trans, direct, storev, m, n, k, v, iv, jv, descv, t, c, ic, jc, descc, work) call pclarfb (side, trans, direct, storev, m, n, k, v, iv, jv, descv, t, c, ic, jc, descc, work) call pzlarfb (side, trans, direct, storev, m, n, k, v, iv, jv, descv, t, c, ic, jc, descc, work) ```

p?larfc applies the conjugate transpose of an elementary reflector to a general matrix.
``` call pclarfc (side, m, n, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pzlarfc (side, m, n, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) ```

p?larfg generates an elementary reflector (Householder matrix).
``` call pslarfg (n, alpha, iax, jax, x, ix, jx, descx, incx, tau) call pdlarfg (n, alpha, iax, jax, x, ix, jx, descx, incx, tau) call pclarfg (n, alpha, iax, jax, x, ix, jx, descx, incx, tau) call pzlarfg (n, alpha, iax, jax, x, ix, jx, descx, incx, tau) ```

p?larft forms the triangular vector T of a block reflector H=I-VTVH.
``` call pslarft (direct, storev, n, k, v, iv, jv, descv, tau, t, work) call pdlarft (direct, storev, n, k, v, iv, jv, descv, tau, t, work) call pclarft (direct, storev, n, k, v, iv, jv, descv, tau, t, work) call pzlarft (direct, storev, n, k, v, iv, jv, descv, tau, t, work) ```

p?larz applies an elementary reflector as returned by `p?tzrzf` to a general matrix.
``` call pslarz (side, m, n, l, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pdlarz (side, m, n, l, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pclarz (side, m, n, l, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pzlarz (side, m, n, l, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) ```

p?larzb applies a block reflector or its transpose/conjugate-transpose as returned by `p?tzrzf` to a general matrix.
``` call pslarzb (side, trans, direct, storev, m, n, k, l, v, iv, jv, descv, t, c, ic, jc, descc, work) call pdlarzb (side, trans, direct, storev, m, n, k, l, v, iv, jv, descv, t, c, ic, jc, descc, work) call pclarzb (side, trans, direct, storev, m, n, k, l, v, iv, jv, descv, t, c, ic, jc, descc, work) call pzlarzb (side, trans, direct, storev, m, n, k, l, v, iv, jv, descv, t, c, ic, jc, descc, work) ```

p?larzc applies (multiplies by) the conjugate transpose of an elementary reflector as returned by `p?tzrzf` to a general matrix.
``` call pclarzc (side, m, n, l, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) call pzlarzc (side, m, n, l, v, iv, jv, descv, incv, tau, c, ic, jc, descc, work) ```

p?larzt forms the triangular vector T of a block reflector H=I-VTVH as returned by `p?tzrzf`.
``` call pslarzt (direct, storev, n, k, v, iv, jv, descv, tau, t, work) call pdlarzt (direct, storev, n, k, v, iv, jv, descv, tau, t, work) call pclarzt (direct, storev, n, k, v, iv, jv, descv, tau, t, work) call pzlarzt (direct, storev, n, k, v, iv, jv, descv, tau, t, work) ```

p?lascl mulitplies a general rectangular matrix by a real scalar defined as `Cto/Cfrom` .
``` call pslascl (type, cfrom, cto, m, n, a, ia, ja, desca, info) call pdlascl (type, cfrom, cto, m, n, a, ia, ja, desca, info) call pclascl (type, cfrom, cto, m, n, a, ia, ja, desca, info) call pzlascl (type, cfrom, cto, m, n, a, ia, ja, desca, info) ```

p?laset initializes the off-diagonal elements of a matrix to `α` and the diagonal elements to `β`.
``` call pslaset (uplo, m, n, alpha, beta, a, ia, ja, desca) call pdlaset (uplo, m, n, alpha, beta, a, ia, ja, desca) call pclaset (uplo, m, n, alpha, beta, a, ia, ja, desca) call pzlaset (uplo, m, n, alpha, beta, a, ia, ja, desca) ```

p?lasmsub looks for a small subdiagonal element from the bottom of the matrix that it can safely set to zero.
``` call pslasmsub (a, desca, i, l, k, smlnum, buf, lwork) call pdlasmsub (a, desca, i, l, k, smlnum, buf, lwork) ```

p?lassq updates a sum of squares represented in scaled form.
``` call pslassq (n, x, ix, jx, descx, incx, scale, sumsq) call pdlassq (n, x, ix, jx, descx, incx, scale, sumsq) call pclassq (n, x, ix, jx, descx, incx, scale, sumsq) call pzlassq (n, x, ix, jx, descx, incx, scale, sumsq) ```

p?laswp performs a series of row interchanges on a general rectangular matrix.
``` call pslaswp (direc, rowcol, n, a, ia, ja, desca, k1, k2, ipiv) call pdlaswp (direc, rowcol, n, a, ia, ja, desca, k1, k2, ipiv) call pclaswp (direc, rowcol, n, a, ia, ja, desca, k1, k2, ipiv) call pzlaswp (direc, rowcol, n, a, ia, ja, desca, k1, k2, ipiv) ```

p?latra computes the trace of a general square distributed matrix.
``` val = pslatra (n, a, ia, ja, desca) val = pdlatra (n, a, ia, ja, desca) val = pclatra (n, a, ia, ja, desca) val = pzlatra (n, a, ia, ja, desca) ```

p?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 pslatrd (uplo, n, nb, a, ia, ja, desca, d, e, tau, w, iw, jw, descw, work) call pdlatrd (uplo, n, nb, a, ia, ja, desca, d, e, tau, w, iw, jw, descw, work) call pclatrd (uplo, n, nb, a, ia, ja, desca, d, e, tau, w, iw, jw, descw, work) call pzlatrd (uplo, n, nb, a, ia, ja, desca, d, e, tau, w, iw, jw, descw, work) ```

p?latrs solves a triangular system of equations with the scale factor set to prevent overflow.
``` call pslatrs (uplo, trans, diag, normin, n, a, ia, ja, desca, x, ix, jx, descx, scale, cnorm, work) call pdlatrs (uplo, trans, diag, normin, n, a, ia, ja, desca, x, ix, jx, descx, scale, cnorm, work) call pclatrs (uplo, trans, diag, normin, n, a, ia, ja, desca, x, ix, jx, descx, scale, cnorm, work) call pzlatrs (uplo, trans, diag, normin, n, a, ia, ja, desca, x, ix, jx, descx, scale, cnorm, work) ```

p?latrz reduces an upper trapezoidal matrix to upper triangular form by means of orthogonal/unitary transformations.
``` call pslatrz (m, n, l, a, ia, ja, desca, tau, work) call pdlatrz (m, n, l, a, ia, ja, desca, tau, work) call pclatrz (m, n, l, a, ia, ja, desca, tau, work) call pzlatrz (m, n, l, a, ia, ja, desca, tau, work) ```

p?lauu2 computes the product UUH or LHL, where U and L are upper or lower triangular matrices (local unblocked algorithm).
``` call pslauu2 (uplo, n, a, ia, ja, desca) call pdlauu2 (uplo, n, a, ia, ja, desca) call pclauu2 (uplo, n, a, ia, ja, desca) call pzlauu2 (uplo, n, a, ia, ja, desca) ```

p?lauum computes the product UUH or LHL, where U and L are upper or lower triangular matrices (local unblocked algorithm).
``` call pslauum (uplo, n, a, ia, ja, desca) call pdlauum (uplo, n, a, ia, ja, desca) call pclauum (uplo, n, a, ia, ja, desca) call pzlauum (uplo, n, a, ia, ja, desca) ```

p?lawil forms the Wilkinson transform.
``` call pslawil (ii, jj, m, a, desca, h44, h33, h43h34, v) call pdlawil (ii, jj, m, a, desca, h44, h33, h43h34, v) ```

p?org2l/p?ung2l generates all or part of the orthogonal/unitary matrix Q from a QL factorization determined by `p?geqlf` (unblocked algorithm).
``` call psorg2l (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pdorg2l (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pcung2l (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pzung2l (m, n, k, a, ia, ja, desca, tau, work, lwork, info) ```

p?org2r/p?ung2r generates all or part of the orthogonal/unitary matrix Q from a QR factorization determined by `p?geqrf` (unblocked algorithm).
``` call psorg2r (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pdorg2r (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pcung2r (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pzung2r (m, n, k, a, ia, ja, desca, tau, work, lwork, info) ```

p?orgl2/p?ungl2 generates all or part of the orthogonal/unitary matrix Q from an LQ factorization determined by `p?gelqf` (unblocked algorithm).
``` call psorgl2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pdorgl2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pcungl2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pzungl2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) ```

p?orgr2/p?ungr2 generates all or part of the orthogonal/unitary matrix Q from an RQ factorization determined by `p?gerqf` (unblocked algorithm).
``` call psorgr2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pdorgr2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pcungr2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) call pzungr2 (m, n, k, a, ia, ja, desca, tau, work, lwork, info) ```

p?orm2l/p?unm2l multiplies a general matrix by the orthogonal/unitary matrix from a QL factorization determined by `p?geqlf` (unblocked algorithm).
``` call psorm2l (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pdorm2l (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pcunm2l (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pzunm2l (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) ```

p?orm2r/p?unm2r multiplies a general matrix by the orthogonal/unitary matrix from a QR factorization determined by `p?geqrf` (unblocked algorithm).
``` call psorm2r (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pdorm2r (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pcunm2r (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pzunm2r (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) ```

p?orml2/p?unml2 multiplies a general matrix by the orthogonal/unitary matrix from an LQ factorization determined by `p?gelqf` (unblocked algorithm).
``` call psorml2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pdorml2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pcunml2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pzunml2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) ```

p?ormr2/p?unmr2 multiplies a general matrix by the orthogonal/unitary matrix from an RQ factorization determined by `p?gerqf` (unblocked algorithm).
``` call psormr2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pdormr2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pcunmr2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) call pzunmr2 (side, trans, m, n, k, a, ia, ja, desca, tau, c, ic, jc, descc, work, lwork, info) ```

p?pbtrsv solves a single triangular linear system via frontsolve or backsolve where the triangular matrix is a factor of a banded matrix computed by `p?pbtrf`.
``` call pspbtrsv (uplo, trans, n, bw, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pdpbtrsv (uplo, trans, n, bw, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pcpbtrsv (uplo, trans, n, bw, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pzpbtrsv (uplo, trans, n, bw, nrhs, a, ja, desca, b, ib, descb, af, laf, work, lwork, info) ```

p?pttrsv solves a single triangular linear system via frontsolve or backsolve where the triangular matrix is a factor of a tridiagonal matrix computed by `p?pttrf`.
``` call pspttrsv (uplo, n, nrhs, d, e, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pdpttrsv (uplo, n, nrhs, d, e, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pcpttrsv (uplo, n, nrhs, d, e, ja, desca, b, ib, descb, af, laf, work, lwork, info) call pzpttrsv (uplo, n, nrhs, d, e, ja, desca, b, ib, descb, af, laf, work, lwork, info) ```

p?potf2 computes the Cholesky factorization of a symmetric/Hermitian positive definite matrix (local unblocked algorithm).
``` call pspotf2 (uplo, n, a, ia, ja, desca, info) call pdpotf2 (uplo, n, a, ia, ja, desca, info) call pcpotf2 (uplo, n, a, ia, ja, desca, info) call pzpotf2 (uplo, n, a, ia, ja, desca, info) ```

p?rscl multiplies a vector by the reciprocal of a real scalar.
``` call psrscl (n, sa, sx, ix, jx, descx, incx) call pdrscl (n, sa, sx, ix, jx, descx, incx) call pcsrscl (n, sa, sx, ix, jx, descx, incx) call pzdrscl (n, sa, sx, ix, jx, descx, incx) ```

p?sygs2/p?hegs2 reduces a symmetric/Hermitian definite generalized eigenproblem to standard form, using the factorization results obtained from `p?potrf` (local unblocked algorithm).
``` call pssygs2 (ibtype, uplo, n, a, ia, ja, desca, b, ib, jb, descb, info) call pdsygs2 (ibtype, uplo, n, a, ia, ja, desca, b, ib, jb, descb, info) call pchegs2 (ibtype, uplo, n, a, ia, ja, desca, b, ib, jb, descb, info) call pzhegs2 (ibtype, uplo, n, a, ia, ja, desca, b, ib, jb, descb, info) ```

p?sytd2/p?hetd2 reduces a symmetric/Hermitian matrix to real symmetric tridiagonal form by an orthogonal/unitary similarity transformation (local unblocked algorithm).
``` call pssytd2 (uplo, n, a, ia, ja, desca, d, e, tau, work, lwork, info) call pdsytd2 (uplo, n, a, ia, ja, desca, d, e, tau, work, lwork, info) call pchetd2 (uplo, n, a, ia, ja, desca, d, e, tau, work, lwork, info) call pzhetd2 (uplo, n, a, ia, ja, desca, d, e, tau, work, lwork, info) ```

p?trti2 computes the inverse of a triangular matrix (local unblocked algorithm).
``` call pstrti2 (uplo, diag, n, a, ia, ja, desca, info) call pdtrti2 (uplo, diag, n, a, ia, ja, desca, info) call pctrti2 (uplo, diag, n, a, ia, ja, desca, info) call pztrti2 (uplo, diag, n, a, ia, ja, desca, info) ```

?lamsh sends multiple shifts through a small (single node) matrix to maximize the number of bulges that can be sent through.
``` call slamsh (s, lds, nbulge, jblk, h, ldh, n, ulp) call dlamsh (s, lds, nbulge, jblk, h, ldh, n, ulp) ```

?laref applies Householder reflectors to matrices on either their rows or columns.
``` call slaref (type, a, lda, wantz, z, ldz, block, irow1, icol1, istart, istop, itmp1, itm2, liloz, lihiz, vecs, v2, v3, t1, t2, t3) call dlaref (type, a, lda, wantz, z, ldz, block, irow1, icol1, istart, istop, itmp1, itm2, liloz, lihiz, vecs, v2, v3, t1, t2, t3) ```

?lasorte sorts eigenpairs by real and complex data types.
``` call slasorte (s, lds, j, out, info) call dlasorte (s, lds, j, out, info) ```

?lasrt2 sorts numbers in increasing or decreasing order.
``` call slasrt2 (id, n, d, key, info) call dlasrt2 (id, n, d, key, info) ```

?stein2 computes the eigenvectors corresponding to specified eigenvalues of a real symmetric tridiagonal matrix, using inverse iteration.
``` call sstein2 (n, d, e, m, w, iblock, isplit, orfac, z, ldz, work, iwork, ifail, info) call dstein2 (n, d, e, m, w, iblock, isplit, orfac, z, ldz, work, iwork, ifail, info) ```

?dbtf2 computes an LU factorization of a general band matrix with no pivoting (local unblocked algorithm).
``` call sdbtf2 (m, n, kl, ku, ab, ldab, info) call ddbtf2 (m, n, kl, ku, ab, ldab, info) call cdbtf2 (m, n, kl, ku, ab, ldab, info) call zdbtf2 (m, n, kl, ku, ab, ldab, info) ```

?dbtrf computes an LU factorization of a general band matrix with no pivoting (local blocked algorithm).
``` call sdbtrf (m, n, kl, ku, ab, ldab, info) call ddbtrf (m, n, kl, ku, ab, ldab, info) call cdbtrf (m, n, kl, ku, ab, ldab, info) call zdbtrf (m, n, kl, ku, ab, ldab, info) ```

?dttrf computes an LU factorization of a general tridiagonal matrix with no pivoting (local blocked algorithm).
``` call sdttrf (n, dl, d, du, info) call ddttrf (n, dl, d, du, info) call cdttrf (n, dl, d, du, info) call zdttrf (n, dl, d, du, info) ```

?dttrsv solves a general tridiagonal system of linear equations using the LU factorization computed by `?dttrf`.
``` call sdttrsv (uplo, trans, n, nrhs, dl, d, du, b, ldb, info) call ddttrsv (uplo, trans, n, nrhs, dl, d, du, b, ldb, info) call cdttrsv (uplo, trans, n, nrhs, dl, d, du, b, ldb, info) call zdttrsv (uplo, trans, n, nrhs, dl, d, du, b, ldb, info) ```

?pttrsv solves a symmetric (Hermitian) positive-definite tridiagonal system of linear equations, using the LDLH factorization computed by `?pttrf`.
``` call spttrsv (trans, n, nrhs, d, e, b, ldb, info) call dpttrsv (trans, n, nrhs, d, e, b, ldb, info) call cpttrsv (uplo, trans, n, nrhs, d, e, b, ldb, info) call zpttrsv (uplo, trans, n, nrhs, d, e, b, ldb, info) ```

?steqr2 computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the implicit QL or QR method.
``` call ssteqr2 (compz, n, d, e, z, ldz, nr, work, info) call dsteqr2 (compz, n, d, e, z, ldz, nr, work, info) ```

#### Utility Routines

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

p?lachkieee performs a simple check for the features of the IEEE standard (C interface function).
``` void pslachkieee (int *isieee, float *rmax, float *rmin); void pdlachkieee (int *isieee, float *rmax, float *rmin); ```

p?lamch determines machine parameters for floating-point arithmetic.
``` val = pslamch (ictxt, cmach) val = pdlamch (ictxt, cmach) ```

p?lasnbt computes the position of the sign bit of a floating-point number (C interface function).
``` val = pslasnbt (int *ieflag); val = pdlasnbt (int *ieflag); ```

pxerbla is error handling routine called by ScaLAPACK routines.
``` call pxerbla (ictxt, srname, info) ```

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