**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

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.*nb*

```
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

columns of a general rectangular matrix A so that elements
below the *nb**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

is distributed
across rows and that all process columns contain the same copy of *bycol*```
```

.*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

is distributed
across columns and that all process rows contain the same copy of *byrow*```
```

.
The output array *byrow**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*-*VTV ^{H}*.

```
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*-*VTV ^{H}* 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

.*C _{to}/C_{from}*

```
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

rows and columns of a symmetric/Hermitian matrix A
to real tridiagonal form by an orthogonal/unitary similarity transformation.*nb*

```
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 *UU ^{H}* or

```
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 *UU ^{H}* or

```
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 *LDL ^{H}* 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*)

**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