# Module scid.bindings.lapack.lapack

LAPACK bindings for D.

## Functions

Name | Description |
---|---|

`cbdsqr_(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info, uplo_len)` | |

`cgbbrd_(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info, vect_len)` | |

`cgbcon_(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info, norm_len)` | |

`cgbequ_(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)` | |

`cgbrfs_(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, trans_len)` | |

`cgbsvx_(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, trans_len, equed_len)` | |

`cgbsv_(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)` | |

`cgbtrf_(m, n, kl, ku, ab, ldab, ipiv, info)` | |

`cgbtrs_(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info, trans_len)` | |

`cgebak_(job, side, n, ilo, ihi, scale, m, v, ldv, info, job_len, side_len)` | |

`cgebal_(job, n, a, lda, ilo, ihi, scale, info, job_len)` | |

`cgebrd_(m, n, a, lda, d, e, tauq, taup, work, lwork, info)` | |

`cgecon_(norm, n, a, lda, anorm, rcond, work, rwork, info, norm_len)` | |

`cgeequ_(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)` | |

`cgeesx_(jobvs, sort, select, sense, n, a, lda, sdim, w, vs, ldvs, rconde, rcondv, work, lwork, rwork, bwork, info, jobvs_len, sort_len, sense_len)` | |

`cgees_(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info, jobvs_len, sort_len)` | |

`cgeevx_(balanc, jobvl, jobvr, sense, n, a, lda, w, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, rwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | |

`cgeev_(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info, jobvl_len, jobvr_len)` | |

`cgegs_(jobvsl, jobvsr, n, a, lda, b, ldb, alphav, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, info, jobvsl_len, jobvsr_len)` | |

`cgegv_(jobvl, jobvr, n, a, lda, b, ldb, alphar, betav, vl, ldvl, vr, ldvr, work, lwork, rwork, info, jobvl_len, jobvr_len)` | |

`cgehrd_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | |

`cgelqf_(m, n, a, lda, tau, work, lwork, info)` | |

`cgelsd_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info)` | |

`cgelss_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info)` | |

`cgelsx_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, rwork, info)` | |

`cgelsy_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info)` | |

`cgels_(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info, trans_len)` | |

`cgeqlf_(m, n, a, lda, tau, work, lwork, info)` | |

`cgeqp3_(m, n, a, lda, jpvt, tau, work, lwork, rwork, info)` | |

`cgeqpf_(m, n, a, lda, jpvt, tau, work, rwork, info)` | |

`cgeqrf_(m, n, a, lda, tau, work, lwork, info)` | |

`cgerfs_(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, trans_len)` | |

`cgerqf_(m, n, a, lda, tau, work, lwork, info)` | |

`cgesdd_(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info, jobz_len)` | |

`cgesvd_(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info, jobu_len, jobvt_len)` | |

`cgesvx_(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, trans_len, equed_len)` | |

`cgesv_(n, nrhs, a, lda, ipiv, b, ldb, info)` | |

`cgetrf_(m, n, a, lda, ipiv, info)` | |

`cgetri_(n, a, lda, ipiv, work, lwork, info)` | |

`cgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info, trans_len)` | |

`cggbak_(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info, job_len, side_len)` | |

`cggbal_(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info, job_len)` | |

`cggesx_(jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alphav, betav, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, bwork, info, jobvsl_len, jobvsr_len, sort_len, sense_len)` | |

`cgges_(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphav, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info, jobvsl_len, jobvsr_len, sort_len)` | |

`cggevx_(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphav, betav, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, rwork, iwork, bwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | |

`cggev_(jobvl, jobvr, n, a, lda, b, ldb, alphav, betav, vl, ldvl, vr, ldvr, work, lwork, rwork, info, jobvl_len, jobvr_len)` | |

`cggglm_(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)` | |

`cgghrd_(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info, compq_len, compz_len)` | |

`cgglse_(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)` | |

`cggqrf_(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)` | |

`cggrqf_(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)` | |

`cggsvd_(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alphav, betav, u, ldu, v, ldv, q, ldq, work, rwork, iwork, info, jobu_len, jobv_len, jobq_len)` | |

`cggsvp_(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, ldv, q, ldq, iwork, rwork, tau, work, info, jobu_len, jobv_len, jobq_len)` | |

`cgtcon_(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info, norm_len)` | |

`cgtrfs_(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, trans_len)` | |

`cgtsvx_(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, trans_len)` | |

`cgtsv_(n, nrhs, dl, d, du, b, ldb, info)` | |

`cgttrf_(n, dl, d, du, du2, ipiv, info)` | |

`cgttrs_(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info, trans_len)` | |

`chbevd_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`chbevx_(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues and eigenvectors of a Hermitian band matrix. |

`chbev_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian band matrix. |

`chbgst_(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info, vect_len, uplo_len)` | Reduces a complex Hermitian-definite banded generalized eigenproblem A x = lambda B x to standard form, where B has been factorized by CPBSTF (Crawford's algorithm). |

`chbgvd_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. A and B are assumed to be Hermitian and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`chbgvx_(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. A and B are assumed to be Hermitian and banded, and B is also positive definite. |

`chbgv_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | Computes all the eigenvalues, and optionally, the eigenvectors of a complex generalized Hermitian-definite banded eigenproblem, of the form A*x=(lambda)*B*x. A and B are assumed to be Hermitian and banded, and B is also positive definite. |

`chbtrd_(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info, vect_len, uplo_len)` | Reduces a Hermitian band matrix to real symmetric tridiagonal form by a unitary similarity transformation. |

`checon_(uplo, n, a, lda, ipiv, anorm, rcond, work, info, uplo_len)` | Estimates the reciprocal of the condition number of a complex Hermitian indefinite matrix, using the factorization computed by CHETRF. |

`cheevd_(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`cheevr_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, eigenvectors of a complex Hermitian matrix. Eigenvalues are computed by the dqds algorithm, and eigenvectors are computed from various "good" LDL^T representations (also known as Relatively Robust Representations). |

`cheevx_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues and eigenvectors of a Hermitian matrix. |

`cheev_(jobz, uplo, n, a, lda, w, work, lwork, rwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix. |

`chegst_(itype, uplo, n, a, lda, b, ldb, info, uplo_len)` | Reduces a Hermitian-definite generalized eigenproblem Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, to standard form, where B has been factorized by CPOTRF. |

`chegvd_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and the eigenvectors of a generalized Hermitian-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`chegvx_(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, the eigenvectors of a generalized Hermitian-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x. |

`chegv_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and the eigenvectors of a generalized Hermitian-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x. |

`cherfs_(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | Improves the computed solution to a complex Hermitian indefinite system of linear equations AX=B, and provides forward and backward error bounds for the solution. |

`chesvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info, fact_len, uplo_len)` | Solves a complex Hermitian indefinite system of linear equations AX=B, and provides an estimate of the condition number and error bounds on the solution. |

`chesv_(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info, uplo_len)` | Solves a complex Hermitian indefinite system of linear equations AX=B. |

`chetrd_(uplo, n, a, lda, d, e, tau, work, lwork, info, uplo_len)` | Reduces a Hermitian matrix to real symmetric tridiagonal form by an orthogonal/unitary similarity transformation. |

`chetrf_(uplo, n, a, lda, ipiv, work, lwork, info, uplo_len)` | Computes the factorization of a complex Hermitian-indefinite matrix, using the diagonal pivoting method. |

`chetri_(uplo, n, a, lda, ipiv, work, info, uplo_len)` | Computes the inverse of a complex Hermitian indefinite matrix, using the factorization computed by CHETRF. |

`chetrs_(uplo, n, nrhs, a, lda, ipiv, b, ldb, info, uplo_len)` | Solves a complex Hermitian indefinite system of linear equations AX=B, using the factorization computed by CHPTRF. |

`chgeqz_(job, compq, compz, n, ilo, ihi, a, lda, b, ldb, alphav, betav, q, ldq, z, ldz, work, lwork, rwork, info, job_len, compq_len, compz_len)` | |

`chpcon_(uplo, n, ap, ipiv, anorm, rcond, work, info, uplo_len)` | Estimates the reciprocal of the condition number of a complex Hermitian indefinite matrix in packed storage, using the factorization computed by CHPTRF. |

`chpevd_(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`chpevx_(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues and eigenvectors of a Hermitian matrix in packed storage. |

`chpev_(jobz, uplo, n, ap, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | Computes selected eigenvalues, and optionally, eigenvectors of a complex Hermitian matrix. Eigenvalues are computed by the dqds algorithm, and eigenvectors are computed from various "good" LDL^T representations (also known as Relatively Robust Representations). Computes all eigenvalues and, optionally, eigenvectors of a complex Hermitian matrix in packed storage. |

`chpgst_(itype, uplo, n, ap, bp, info, uplo_len)` | Reduces a Hermitian-definite generalized eigenproblem Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, to standard form, where A and B are held in packed storage, and B has been factorized by CPPTRF. |

`chpgvd_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and eigenvectors of a generalized Hermitian-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, where A and B are in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`chpgvx_(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, the eigenvectors of a generalized Hermitian-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, where A and B are in packed storage. |

`chpgv_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and eigenvectors of a generalized Hermitian-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, where A and B are in packed storage. |

`chprfs_(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | Improves the computed solution to a complex Hermitian indefinite system of linear equations AX=B, where A is held in packed storage, and provides forward and backward error bounds for the solution. |

`chpsvx_(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len)` | Solves a complex Hermitian indefinite system of linear equations AX=B, where A is held in packed storage, and provides an estimate of the condition number and error bounds on the solution. |

`chpsv_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | Solves a complex Hermitian indefinite system of linear equations AX=B, where A is held in packed storage. |

`chptrd_(uplo, n, ap, d, e, tau, info, uplo_len)` | Reduces a Hermitian matrix in packed storage to real symmetric tridiagonal form by a unitary similarity transformation. |

`chptrf_(uplo, n, ap, ipiv, info, uplo_len)` | Computes the factorization of a complex Hermitian-indefinite matrix in packed storage, using the diagonal pivoting method. |

`chptri_(uplo, n, ap, ipiv, work, info, uplo_len)` | Computes the inverse of a complex Hermitian indefinite matrix in packed storage, using the factorization computed by CHPTRF. |

`chptrs_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | Solves a complex Hermitian indefinite system of linear equations AX=B, where A is held in packed storage, using the factorization computed by CHPTRF. |

`chsein_(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info, side_len, eigsrc_len, initv_len)` | |

`chseqr_(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info, job_len, compz_len)` | |

`cpbcon_(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info, uplo_len)` | |

`cpbequ_(uplo, n, kd, ab, ldab, s, scond, amax, info, uplo_len)` | |

`cpbrfs_(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`cpbstf_(uplo, n, kd, ab, ldab, info, uplo_len)` | |

`cpbsvx_(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len, equed_len)` | |

`cpbsv_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | |

`cpbtrf_(uplo, n, kd, ab, ldab, info, uplo_len)` | |

`cpbtrs_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | |

`cpocon_(uplo, n, a, lda, anorm, rcond, work, rwork, info, uplo_len)` | |

`cpoequ_(n, a, lda, s, scond, amax, info)` | |

`cporfs_(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`cposvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len, equed_len)` | |

`cposv_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | |

`cpotrf_(uplo, n, a, lda, info, uplo_len)` | |

`cpotri_(uplo, n, a, lda, info, uplo_len)` | |

`cpotrs_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | |

`cppcon_(uplo, n, ap, anorm, rcond, work, rwork, info, uplo_len)` | |

`cppequ_(uplo, n, ap, s, scond, amax, info, uplo_len)` | |

`cpprfs_(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`cppsvx_(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len, equed_len)` | |

`cppsv_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | |

`cpptrf_(uplo, n, ap, info, uplo_len)` | |

`cpptri_(uplo, n, ap, info, uplo_len)` | |

`cpptrs_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | |

`cptcon_(n, d, e, anorm, rcond, rwork, info)` | |

`cpteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | |

`cptrfs_(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`cptsvx_(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len)` | |

`cptsv_(n, nrhs, d, e, b, ldb, info)` | |

`cpttrf_(n, d, e, info)` | |

`cpttrs_(uplo, n, nrhs, d, e, b, ldb, info, uplo_len)` | |

`cspcon_(uplo, n, ap, ipiv, anorm, rcond, work, info, uplo_len)` | |

`csprfs_(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`cspsvx_(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len)` | |

`cspsv_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`csptrf_(uplo, n, ap, ipiv, info, uplo_len)` | |

`csptri_(uplo, n, ap, ipiv, work, info, uplo_len)` | |

`csptrs_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`cstedc_(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, compz_len)` | |

`cstegr_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len)` | |

`cstein_(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)` | |

`csteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | |

`csycon_(uplo, n, a, lda, ipiv, anorm, rcond, work, info, uplo_len)` | |

`csyrfs_(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`csysvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info, fact_len, uplo_len)` | |

`csysv_(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info, uplo_len)` | |

`csytrf_(uplo, n, a, lda, ipiv, work, lwork, info, uplo_len)` | |

`csytri_(uplo, n, a, lda, ipiv, work, info, uplo_len)` | |

`csytrs_(uplo, n, nrhs, a, lda, ipiv, b, ldb, info, uplo_len)` | |

`ctbcon_(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info, norm_len, uplo_len, diag_len)` | |

`ctbrfs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len, trans_len, diag_len)` | |

`ctbtrs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`ctgevc_(side, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, mm, m, work, rwork, info, side_len, howmny_len)` | |

`ctgexc_(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info)` | |

`ctgsen_(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphav, betav, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)` | |

`ctgsja_(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alphav, betav, u, ldu, v, ldv, q, ldq, work, ncycle, info, jobu_len, jobv_len, jobq_len)` | |

`ctgsna_(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info, job_len, howmny_len)` | |

`ctgsyl_(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info, trans_len)` | |

`ctpcon_(norm, uplo, diag, n, ap, rcond, work, rwork, info, norm_len, uplo_len, diag_len)` | |

`ctprfs_(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len, trans_len, diag_len)` | |

`ctptri_(uplo, diag, n, ap, info, uplo_len, diag_len)` | |

`ctptrs_(uplo, trans, diag, n, nrhs, ap, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`ctrcon_(norm, uplo, diag, n, a, lda, rcond, work, rwork, info, norm_len, uplo_len, diag_len)` | |

`ctrevc_(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info, side_len, howmny_len)` | |

`ctrexc_(compq, n, t, ldt, q, ldq, ifst, ilst, info, compq_len)` | |

`ctrrfs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len, trans_len, diag_len)` | |

`ctrsen_(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info, job_len, compq_len)` | |

`ctrsna_(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info, job_len, howmny_len)` | |

`ctrsyl_(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info, trana_len, tranb_len)` | |

`ctrtri_(uplo, diag, n, a, lda, info, uplo_len, diag_len)` | |

`ctrtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`ctzrqf_(m, n, a, lda, tau, info)` | |

`ctzrzf_(m, n, a, lda, tau, work, lwork, info)` | |

`cungbr_(vect, m, n, k, a, lda, tau, work, lwork, info, vect_len)` | Generates the unitary transformation matrices from a reduction to bidiagonal form determined by CGEBRD. |

`cunghr_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | Generates the unitary transformation matrix from a reduction to Hessenberg form determined by CGEHRD. |

`cunglq_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the unitary matrix Q from an LQ factorization determined by CGELQF. |

`cungql_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the unitary matrix Q from a QL factorization determined by CGEQLF. |

`cungqr_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the unitary matrix Q from a QR factorization determined by CGEQRF. |

`cungrq_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the unitary matrix Q from an RQ factorization determined by CGERQF. |

`cungtr_(uplo, n, a, lda, tau, work, lwork, info, uplo_len)` | Generates the unitary transformation matrix from a reduction to tridiagonal form determined by CHETRD. |

`cunmbr_(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, vect_len, side_len, trans_len)` | Multiplies a general matrix by one of the unitary transformation matrices from a reduction to bidiagonal form determined by CGEBRD. |

`cunmhr_(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the unitary transformation matrix from a reduction to Hessenberg form determined by CGEHRD. |

`cunmlq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the unitary matrix from an LQ factorization determined by CGELQF. |

`cunmql_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the unitary matrix from a QL factorization determined by CGEQLF. |

`cunmqr_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the unitary matrix from a QR factorization determined by CGEQRF. |

`cunmr3_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info, side_len, trans_len)` | Multiples a general matrix by the unitary matrix from an RZ factorization determined by CTZRZF. |

`cunmrq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the unitary matrix from an RQ factorization determined by CGERQF. |

`cunmrz_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiples a general matrix by the unitary matrix from an RZ factorization determined by CTZRZF. |

`cunmtr_(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info, side_len, uplo_len, trans_len)` | Multiplies a general matrix by the unitary transformation matrix from a reduction to tridiagonal form determined by CHETRD. |

`cupgtr_(uplo, n, ap, tau, q, ldq, work, info, uplo_len)` | Generates the unitary transformation matrix from a reduction to tridiagonal form determined by CHPTRD. |

`cupmtr_(side, uplo, trans, m, n, ap, tau, c, ldc, work, info, side_len, uplo_len, trans_len)` | Multiplies a general matrix by the unitary transformation matrix from a reduction to tridiagonal form determined by CHPTRD. |

`dbdsdc_(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info, uplo_len, compq_len)` | |

`dbdsqr_(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info, uplo_len)` | |

`ddisna_(job, m, n, d, sep, info, job_len)` | |

`dgbbrd_(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info, vect_len)` | |

`dgbcon_(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info, norm_len)` | |

`dgbequ_(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)` | |

`dgbrfs_(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, trans_len)` | |

`dgbsvx_(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, trans_len, equed_len)` | |

`dgbsv_(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)` | |

`dgbtrf_(m, n, kl, ku, ab, ldab, ipiv, info)` | |

`dgbtrs_(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info, trans_len)` | |

`dgebak_(job, side, n, ilo, ihi, scale, m, v, ldv, info, job_len, side_len)` | |

`dgebal_(job, n, a, lda, ilo, ihi, scale, info, job_len)` | |

`dgebrd_(m, n, a, lda, d, e, tauq, taup, work, lwork, info)` | |

`dgecon_(norm, n, a, lda, anorm, rcond, work, iwork, info, norm_len)` | |

`dgeequ_(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)` | |

`dgeesx_(jobvs, sort, select, sense, n, a, lda, sdim, wr, wi, vs, ldvs, rconde, rcondv, work, lwork, iwork, liwork, bwork, info, jobvs_len, sort_len, sense_len)` | |

`dgees_(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info, jobvs_len, sort_len)` | |

`dgeevx_(balanc, jobvl, jobvr, sense, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | |

`dgeev_(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info, jobvl_len, jobvr_len)` | |

`dgegs_(jobvsl, jobvsr, n, a, lda, b, ldb, alphar, alphai, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, info, jobvsl_len, jobvsr_len)` | |

`dgegv_(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, betav, vl, ldvl, vr, ldvr, work, lwork, info, jobvl_len, jobvr_len)` | |

`dgehrd_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | |

`dgelqf_(m, n, a, lda, tau, work, lwork, info)` | |

`dgelsd_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)` | |

`dgelss_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info)` | |

`dgelsx_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, info)` | |

`dgelsy_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info)` | |

`dgels_(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info, trans_len)` | |

`dgeqlf_(m, n, a, lda, tau, work, lwork, info)` | |

`dgeqp3_(m, n, a, lda, jpvt, tau, work, lwork, info)` | |

`dgeqpf_(m, n, a, lda, jpvt, tau, work, info)` | |

`dgeqrf_(m, n, a, lda, tau, work, lwork, info)` | |

`dgerfs_(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, trans_len)` | |

`dgerqf_(m, n, a, lda, tau, work, lwork, info)` | |

`dgesdd_(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info, jobz_len)` | |

`dgesvd_(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info, jobu_len, jobvt_len)` | |

`dgesvx_(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, trans_len, equed_len)` | |

`dgesv_(n, nrhs, a, lda, ipiv, b, ldb, info)` | |

`dgetrf_(m, n, a, lda, ipiv, info)` | |

`dgetri_(n, a, lda, ipiv, work, lwork, info)` | |

`dgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info, trans_len)` | |

`dggbak_(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info, job_len, side_len)` | |

`dggbal_(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info, job_len)` | |

`dggesx_(jobvsl, jobvsr, sort, delctg, sense, n, a, lda, b, ldb, sdim, alphar, alphai, betav, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, iwork, liwork, bwork, info, jobvsl_len, jobvsr_len, sort_len, sense_len)` | |

`dgges_(jobvsl, jobvsr, sort, delctg, n, a, lda, b, ldb, sdim, alphar, alphai, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info, jobvsl_len, jobvsr_len, sort_len)` | |

`dggevx_(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, betav, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork, bwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | |

`dggev_(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, betav, vl, ldvl, vr, ldvr, work, lwork, info, jobvl_len, jobvr_len)` | |

`dggglm_(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)` | |

`dgghrd_(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info, compq_len, compz_len)` | |

`dgglse_(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)` | |

`dggqrf_(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)` | |

`dggrqf_(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)` | |

`dggsvd_(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alphav, betav, u, ldu, v, ldv, q, ldq, work, iwork, info, jobu_len, jobv_len, jobq_len)` | |

`dggsvp_(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, ldv, q, ldq, iwork, tau, work, info, jobu_len, jobv_len, jobq_len)` | |

`dgtcon_(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info, norm_len)` | |

`dgtrfs_(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, trans_len)` | |

`dgtsvx_(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, trans_len)` | |

`dgtsv_(n, nrhs, dl, d, du, b, ldb, info)` | |

`dgttrf_(n, dl, d, du, du2, ipiv, info)` | |

`dgttrs_(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info, trans_len)` | |

`dhgeqz_(job, compq, compz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, betav, q, ldq, z, ldz, work, lwork, info, job_len, compq_len, compz_len)` | |

`dhsein_(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info, side_len, eigsrc_len, initv_len)` | |

`dhseqr_(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info, job_len, compz_len)` | |

`dlamch_(cmach, cmach_len)` | |

`dopgtr_(uplo, n, ap, tau, q, ldq, work, info, uplo_len)` | |

`dopmtr_(side, uplo, trans, m, n, ap, tau, c, ldc, work, info, side_len, uplo_len, trans_len)` | |

`dorgbr_(vect, m, n, k, a, lda, tau, work, lwork, info, vect_len)` | |

`dorghr_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | |

`dorglq_(m, n, k, a, lda, tau, work, lwork, info)` | |

`dorgql_(m, n, k, a, lda, tau, work, lwork, info)` | |

`dorgqr_(m, n, k, a, lda, tau, work, lwork, info)` | |

`dorgrq_(m, n, k, a, lda, tau, work, lwork, info)` | |

`dorgtr_(uplo, n, a, lda, tau, work, lwork, info, uplo_len)` | |

`dormbr_(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, vect_len, side_len, trans_len)` | |

`dormhr_(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`dormlq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`dormql_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`dormqr_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`dormr3_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info, side_len, trans_len)` | |

`dormrq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`dormrz_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`dormtr_(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info, side_len, uplo_len, trans_len)` | |

`dpbcon_(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info, uplo_len)` | |

`dpbequ_(uplo, n, kd, ab, ldab, s, scond, amax, info, uplo_len)` | |

`dpbrfs_(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | |

`dpbstf_(uplo, n, kd, ab, ldab, info, uplo_len)` | |

`dpbsvx_(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len, equed_len)` | |

`dpbsv_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | |

`dpbtrf_(uplo, n, kd, ab, ldab, info, uplo_len)` | |

`dpbtrs_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | |

`dpocon_(uplo, n, a, lda, anorm, rcond, work, iwork, info, uplo_len)` | |

`dpoequ_(n, a, lda, s, scond, amax, info)` | |

`dporfs_(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | |

`dposvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len, equed_len)` | |

`dposv_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | |

`dpotrf_(uplo, n, a, lda, info, uplo_len)` | |

`dpotri_(uplo, n, a, lda, info, uplo_len)` | |

`dpotrs_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | |

`dppcon_(uplo, n, ap, anorm, rcond, work, iwork, info, uplo_len)` | |

`dppequ_(uplo, n, ap, s, scond, amax, info, uplo_len)` | |

`dpprfs_(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | |

`dppsvx_(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len, equed_len)` | |

`dppsv_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | |

`dpptrf_(uplo, n, ap, info, uplo_len)` | |

`dpptri_(uplo, n, ap, info, uplo_len)` | |

`dpptrs_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | |

`dptcon_(n, d, e, anorm, rcond, work, info)` | |

`dpteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | |

`dptrfs_(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info)` | |

`dptsvx_(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info, fact_len)` | |

`dptsv_(n, nrhs, d, e, b, ldb, info)` | |

`dpttrf_(n, d, e, info)` | |

`dpttrs_(n, nrhs, d, e, b, ldb, info)` | |

`dsbevd_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`dsbevx_(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`dsbev_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info, jobz_len, uplo_len)` | |

`dsbgst_(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info, vect_len, uplo_len)` | |

`dsbgvd_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`dsbgvx_(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`dsbgv_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info, jobz_len, uplo_len)` | |

`dsbtrd_(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info, vect_len, uplo_len)` | |

`dspcon_(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info, uplo_len)` | |

`dspevd_(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`dspevx_(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`dspev_(jobz, uplo, n, ap, w, z, ldz, work, info, jobz_len, uplo_len)` | |

`dspgst_(itype, uplo, n, ap, bp, info, uplo_len)` | |

`dspgvd_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`dspgvx_(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`dspgv_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info, jobz_len, uplo_len)` | |

`dsprfs_(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | |

`dspsvx_(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len)` | |

`dspsv_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`dsptrd_(uplo, n, ap, d, e, tau, info, uplo_len)` | |

`dsptrf_(uplo, n, ap, ipiv, info, uplo_len)` | |

`dsptri_(uplo, n, ap, ipiv, work, info, uplo_len)` | |

`dsptrs_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`dstebz_(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info, range_len, order_len)` | |

`dstedc_(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info, compz_len)` | |

`dstegr_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len)` | |

`dstein_(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)` | |

`dsteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | |

`dsterf_(n, d, e, info)` | |

`dstevd_(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info, jobz_len)` | |

`dstevr_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len)` | |

`dstevx_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len)` | |

`dstev_(jobz, n, d, e, z, ldz, work, info, jobz_len)` | |

`dsycon_(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info, uplo_len)` | |

`dsyevd_(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`dsyevr_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len, uplo_len)` | |

`dsyevx_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`dsyev_(jobz, uplo, n, a, lda, w, work, lwork, info, jobz_len, uplo_len)` | |

`dsygst_(itype, uplo, n, a, lda, b, ldb, info, uplo_len)` | |

`dsygvd_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`dsygvx_(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`dsygv_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info, jobz_len, uplo_len)` | |

`dsyrfs_(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | |

`dsysvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, iwork, info, fact_len, uplo_len)` | |

`dsysv_(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info, uplo_len)` | |

`dsytrd_(uplo, n, a, lda, d, e, tau, work, lwork, info, uplo_len)` | |

`dsytrf_(uplo, n, a, lda, ipiv, work, lwork, info, uplo_len)` | |

`dsytri_(uplo, n, a, lda, ipiv, work, info, uplo_len)` | |

`dsytrs_(uplo, n, nrhs, a, lda, ipiv, b, ldb, info, uplo_len)` | |

`dtbcon_(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info, norm_len, uplo_len, diag_len)` | |

`dtbrfs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len, trans_len, diag_len)` | |

`dtbtrs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`dtgevc_(side, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, mm, m, work, info, side_len, howmny_len)` | |

`dtgexc_(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info)` | |

`dtgsen_(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, betav, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)` | |

`dtgsja_(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alphav, betav, u, ldu, v, ldv, q, ldq, work, ncycle, info, jobu_len, jobv_len, jobq_len)` | |

`dtgsna_(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info, job_len, howmny_len)` | |

`dtgsyl_(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info, trans_len)` | |

`dtpcon_(norm, uplo, diag, n, ap, rcond, work, iwork, info, norm_len, uplo_len, diag_len)` | |

`dtprfs_(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len, trans_len, diag_len)` | |

`dtptri_(uplo, diag, n, ap, info, uplo_len, diag_len)` | |

`dtptrs_(uplo, trans, diag, n, nrhs, ap, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`dtrcon_(norm, uplo, diag, n, a, lda, rcond, work, iwork, info, norm_len, uplo_len, diag_len)` | |

`dtrevc_(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info, side_len, howmny_len)` | |

`dtrexc_(compq, n, t, ldt, q, ldq, ifst, ilst, work, info, compq_len)` | |

`dtrrfs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len, trans_len, diag_len)` | |

`dtrsen_(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info, job_len, compq_len)` | |

`dtrsna_(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info, job_len, howmny_len)` | |

`dtrsyl_(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info, trana_len, tranb_len)` | |

`dtrtri_(uplo, diag, n, a, lda, info, uplo_len, diag_len)` | |

`dtrtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`dtzrqf_(m, n, a, lda, tau, info)` | |

`dtzrzf_(m, n, a, lda, tau, work, lwork, info)` | |

`ilaenvset_(ispec, name, opts, n1, n2, n3, n4, nvalue, info, len_name, len_opts)` | |

`ilaenv_(ispec, name, opts, n1, n2, n3, n4, len_name, len_opts)` | |

`sbdsdc_(uplo, compq, n, d, e, u, ldu, vt, ldvt, q, iq, work, iwork, info, uplo_len, compq_len)` | Computes the singular value decomposition (SVD) of a real bidiagonal matrix, using a divide and conquer method. |

`sbdsqr_(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, work, info, uplo_len)` | Computes the singular value decomposition (SVD) of a real bidiagonal matrix, using the bidiagonal QR algorithm. |

`sdisna_(job, m, n, d, sep, info, job_len)` | Computes the reciprocal condition numbers for the eigenvectors of a real symmetric or complex Hermitian matrix or for the left or right singular vectors of a general matrix. |

`sgbbrd_(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, info, vect_len)` | Reduces a general band matrix to real upper bidiagonal form by an orthogonal transformation. |

`sgbcon_(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, iwork, info, norm_len)` | Estimates the reciprocal of the condition number of a general band matrix, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGBTRF. |

`sgbequ_(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)` | Computes row and column scalings to equilibrate a general band matrix and reduce its condition number. |

`sgbrfs_(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, trans_len)` | Improves the computed solution to a general banded system of linear equations AX=B, A**T X=B or A**H X=B, and provides forward and backward error bounds for the solution. |

`sgbsvx_(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, trans_len, equed_len)` | Solves a general banded system of linear equations AX=B, A**T X=B or A**H X=B, and provides an estimate of the condition number and error bounds on the solution. |

`sgbsv_(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)` | Solves a general banded system of linear equations AX=B. |

`sgbtrf_(m, n, kl, ku, ab, ldab, ipiv, info)` | Computes an LU factorization of a general band matrix, using partial pivoting with row interchanges. |

`sgbtrs_(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info, trans_len)` | Solves a general banded system of linear equations AX=B, A**T X=B or A**H X=B, using the LU factorization computed by SGBTRF. |

`sgebak_(job, side, n, ilo, ihi, scale, m, v, ldv, info, job_len, side_len)` | Transforms eigenvectors of a balanced matrix to those of the original matrix supplied to SGEBAL. |

`sgebal_(job, n, a, lda, ilo, ihi, scale, info, job_len)` | Balances a general matrix in order to improve the accuracy of computed eigenvalues. |

`sgebrd_(m, n, a, lda, d, e, tauq, taup, work, lwork, info)` | Reduces a general rectangular matrix to real bidiagonal form by an orthogonal transformation. |

`sgecon_(norm, n, a, lda, anorm, rcond, work, iwork, info, norm_len)` | Estimates the reciprocal of the condition number of a general matrix, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGETRF. |

`sgeequ_(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)` | Computes row and column scalings to equilibrate a general rectangular matrix and reduce its condition number. |

`sgeesx_(jobvs, sort, select, sense, n, a, lda, sdim, wr, wi, vs, ldvs, rconde, rcondv, work, lwork, iwork, liwork, bwork, info, jobvs_len, sort_len, sense_len)` | Computes the eigenvalues and Schur factorization of a general matrix, orders the factorization so that selected eigenvalues are at the top left of the Schur form, and computes reciprocal condition numbers for the average of the selected eigenvalues, and for the associated right invariant subspace. |

`sgees_(jobvs, sort, select, n, a, lda, sdim, wr, wi, vs, ldvs, work, lwork, bwork, info, jobvs_len, sort_len)` | Computes the eigenvalues and Schur factorization of a general matrix, and orders the factorization so that selected eigenvalues are at the top left of the Schur form. |

`sgeevx_(balanc, jobvl, jobvr, sense, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, iwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | Computes the eigenvalues and left and right eigenvectors of a general matrix, with preliminary balancing of the matrix, and computes reciprocal condition numbers for the eigenvalues and right eigenvectors. |

`sgeev_(jobvl, jobvr, n, a, lda, wr, wi, vl, ldvl, vr, ldvr, work, lwork, info, jobvl_len, jobvr_len)` | Computes the eigenvalues and left and right eigenvectors of a general matrix. |

`sgegs_(jobvsl, jobvsr, n, a, lda, b, ldb, alphar, alphai, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, info, jobvsl_len, jobvsr_len)` | Computes the generalized eigenvalues, Schur form, and left and/or right Schur vectors for a pair of nonsymmetric matrices |

`sgegv_(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, betav, vl, ldvl, vr, ldvr, work, lwork, info, jobvl_len, jobvr_len)` | Computes the generalized eigenvalues, and left and/or right generalized eigenvectors for a pair of nonsymmetric matrices |

`sgehrd_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | Reduces a general matrix to upper Hessenberg form by an orthogonal similarity transformation. |

`sgelqf_(m, n, a, lda, tau, work, lwork, info)` | Computes an LQ factorization of a general rectangular matrix. |

`sgelsd_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, iwork, info)` | Computes the least squares solution to an over-determined system of linear equations, A X=B or A**H X=B, or the minimum norm solution of an under-determined system, using a divide and conquer method, where A is a general rectangular matrix of full rank, using a QR or LQ factorization of A. |

`sgelss_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, info)` | Computes the minimum norm least squares solution to an over- or under-determined system of linear equations A X=B, using the singular value decomposition of A. |

`sgelsx_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, info)` | Computes the minimum norm least squares solution to an over- or under-determined system of linear equations A X=B, using a complete orthogonal factorization of A. |

`sgelsy_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, info)` | Computes the minimum norm least squares solution to an over- or under-determined system of linear equations A X=B, using a complete orthogonal factorization of A. |

`sgels_(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info, trans_len)` | Computes the least squares solution to an over-determined system of linear equations, A X=B or A**H X=B, or the minimum norm solution of an under-determined system, where A is a general rectangular matrix of full rank, using a QR or LQ factorization of A. |

`sgeqlf_(m, n, a, lda, tau, work, lwork, info)` | Computes a QL factorization of a general rectangular matrix. |

`sgeqp3_(m, n, a, lda, jpvt, tau, work, lwork, info)` | Computes a QR factorization with column pivoting of a general rectangular matrix using Level 3 BLAS. |

`sgeqpf_(m, n, a, lda, jpvt, tau, work, info)` | Computes a QR factorization with column pivoting of a general rectangular matrix. |

`sgeqrf_(m, n, a, lda, tau, work, lwork, info)` | Computes a QR factorization of a general rectangular matrix. |

`sgerfs_(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, trans_len)` | Improves the computed solution to a general system of linear equations AX=B, A**T X=B or A**H X=B, and provides forward and backward error bounds for the solution. |

`sgerqf_(m, n, a, lda, tau, work, lwork, info)` | Computes an RQ factorization of a general rectangular matrix. |

`sgesdd_(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, iwork, info, jobz_len)` | Computes the singular value decomposition (SVD) of a general rectangular matrix using divide-and-conquer. |

`sgesvd_(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info, jobu_len, jobvt_len)` | Computes the singular value decomposition (SVD) of a general rectangular matrix. |

`sgesvx_(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, trans_len, equed_len)` | Solves a general system of linear equations AX=B, A**T X=B or A**H X=B, and provides an estimate of the condition number and error bounds on the solution. |

`sgesv_(n, nrhs, a, lda, ipiv, b, ldb, info)` | Solves a general system of linear equations AX=B. |

`sgetrf_(m, n, a, lda, ipiv, info)` | Computes an LU factorization of a general matrix, using partial pivoting with row interchanges. |

`sgetri_(n, a, lda, ipiv, work, lwork, info)` | Computes the inverse of a general matrix, using the LU factorization computed by SGETRF. |

`sgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info, trans_len)` | Solves a general system of linear equations AX=B, A**T X=B or A**H X=B, using the LU factorization computed by SGETRF. |

`sggbak_(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info, job_len, side_len)` | Forms the right or left eigenvectors of the generalized eigenvalue problem by backward transformation on the computed eigenvectors of the balanced pair of matrices output by SGGBAL. |

`sggbal_(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info, job_len)` | Balances a pair of general real matrices for the generalized eigenvalue problem A x = lambda B x. |

`sggesx_(jobvsl, jobvsr, sort, selctg, sense, n, a, lda, b, ldb, sdim, alphar, alphai, betav, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, iwork, liwork, bwork, info, jobvsl_len, jobvsr_len, sort_len, sense_len)` | Computes the generalized eigenvalues, the real Schur form, and, optionally, the left and/or right matrices of Schur vectors. |

`sgges_(jobvsl, jobvsr, sort, selctg, n, a, lda, b, ldb, sdim, alphar, alphai, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, bwork, info, jobvsl_len, jobvsr_len, sort_len)` | Computes the generalized eigenvalues, Schur form, and left and/or right Schur vectors for a pair of nonsymmetric matrices |

`sggevx_(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphar, alphai, betav, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, iwork, bwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | Computes the generalized eigenvalues, and optionally, the left and/or right generalized eigenvectors. |

`sggev_(jobvl, jobvr, n, a, lda, b, ldb, alphar, alphai, betav, vl, ldvl, vr, ldvr, work, lwork, info, jobvl_len, jobvr_len)` | Computes the generalized eigenvalues, and left and/or right generalized eigenvectors for a pair of nonsymmetric matrices |

`sggglm_(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)` | Solves the GLM (Generalized Linear Regression Model) using the GQR (Generalized QR) factorization |

`sgghrd_(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info, compq_len, compz_len)` | Reduces a pair of real matrices to generalized upper Hessenberg form using orthogonal transformations |

`sgglse_(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)` | Solves the LSE (Constrained Linear Least Squares Problem) using the GRQ (Generalized RQ) factorization |

`sggqrf_(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)` | Computes a generalized QR factorization of a pair of matrices. |

`sggrqf_(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)` | Computes a generalized RQ factorization of a pair of matrices. |

`sggsvd_(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alphav, betav, u, ldu, v, ldv, q, ldq, work, iwork, info, jobu_len, jobv_len, jobq_len)` | Computes the Generalized Singular Value Decomposition |

`sggsvp_(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, ldv, q, ldq, iwork, tau, work, info, jobu_len, jobv_len, jobq_len)` | Computes orthogonal matrices as a preprocessing step for computing the generalized singular value decomposition |

`sgtcon_(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, iwork, info, norm_len)` | Estimates the reciprocal of the condition number of a general tridiagonal matrix, in either the 1-norm or the infinity-norm, using the LU factorization computed by SGTTRF. |

`sgtrfs_(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, trans_len)` | Improves the computed solution to a general tridiagonal system of linear equations AX=B, A**T X=B or A**H X=B, and provides forward and backward error bounds for the solution. |

`sgtsvx_(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, trans_len)` | Solves a general tridiagonal system of linear equations AX=B, A**T X=B or A**H X=B, and provides an estimate of the condition number and error bounds on the solution. |

`sgtsv_(n, nrhs, dl, d, du, b, ldb, info)` | Solves a general tridiagonal system of linear equations AX=B. |

`sgttrf_(n, dl, d, du, du2, ipiv, info)` | Computes an LU factorization of a general tridiagonal matrix, using partial pivoting with row interchanges. |

`sgttrs_(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info, trans_len)` | Solves a general tridiagonal system of linear equations AX=B, A**T X=B or A**H X=B, using the LU factorization computed by SGTTRF. |

`shgeqz_(job, compq, compz, n, ilo, ihi, a, lda, b, ldb, alphar, alphai, betav, q, ldq, z, ldz, work, lwork, info, job_len, compq_len, compz_len)` | Implements a single-/f_double-shift version of the QZ method for finding the generalized eigenvalues of the equation det(A - w(i) B) = 0 |

`shsein_(side, eigsrc, initv, select, n, h, ldh, wr, wi, vl, ldvl, vr, ldvr, mm, m, work, ifaill, ifailr, info, side_len, eigsrc_len, initv_len)` | Computes specified right and/or left eigenvectors of an upper Hessenberg matrix by inverse iteration. |

`shseqr_(job, compz, n, ilo, ihi, h, ldh, wr, wi, z, ldz, work, lwork, info, job_len, compz_len)` | Computes the eigenvalues and Schur factorization of an upper Hessenberg matrix, using the multishift QR algorithm. |

`slamch_(cmach, cmach_len)` | |

`sopgtr_(uplo, n, ap, tau, q, ldq, work, info, uplo_len)` | Generates the orthogonal transformation matrix from a reduction to tridiagonal form determined by SSPTRD. |

`sopmtr_(side, uplo, trans, m, n, ap, tau, c, ldc, work, info, side_len, uplo_len, trans_len)` | Multiplies a general matrix by the orthogonal transformation matrix from a reduction to tridiagonal form determined by SSPTRD. |

`sorgbr_(vect, m, n, k, a, lda, tau, work, lwork, info, vect_len)` | Generates the orthogonal transformation matrices from a reduction to bidiagonal form determined by SGEBRD. |

`sorghr_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | Generates the orthogonal transformation matrix from a reduction to Hessenberg form determined by SGEHRD. |

`sorglq_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the orthogonal matrix Q from an LQ factorization determined by SGELQF. |

`sorgql_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the orthogonal matrix Q from a QL factorization determined by SGEQLF. |

`sorgqr_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the orthogonal matrix Q from a QR factorization determined by SGEQRF. |

`sorgrq_(m, n, k, a, lda, tau, work, lwork, info)` | Generates all or part of the orthogonal matrix Q from an RQ factorization determined by SGERQF. |

`sorgtr_(uplo, n, a, lda, tau, work, lwork, info, uplo_len)` | Generates the orthogonal transformation matrix from a reduction to tridiagonal form determined by SSYTRD. |

`sormbr_(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, vect_len, side_len, trans_len)` | Multiplies a general matrix by one of the orthogonal transformation matrices from a reduction to bidiagonal form determined by SGEBRD. |

`sormhr_(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the orthogonal transformation matrix from a reduction to Hessenberg form determined by SGEHRD. |

`sormlq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the orthogonal matrix from an LQ factorization determined by SGELQF. |

`sormql_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the orthogonal matrix from a QL factorization determined by SGEQLF. |

`sormqr_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the orthogonal matrix from a QR factorization determined by SGEQRF. |

`sormr3_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info, side_len, trans_len)` | Multiples a general matrix by the orthogonal matrix from an RZ factorization determined by STZRZF. |

`sormrq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiplies a general matrix by the orthogonal matrix from an RQ factorization determined by SGERQF. |

`sormrz_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | Multiples a general matrix by the orthogonal matrix from an RZ factorization determined by STZRZF. |

`sormtr_(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info, side_len, uplo_len, trans_len)` | Multiplies a general matrix by the orthogonal transformation matrix from a reduction to tridiagonal form determined by SSYTRD. |

`spbcon_(uplo, n, kd, ab, ldab, anorm, rcond, work, iwork, info, uplo_len)` | Estimates the reciprocal of the condition number of a symmetric positive definite band matrix, using the Cholesky factorization computed by SPBTRF. |

`spbequ_(uplo, n, kd, ab, ldab, s, scond, amax, info, uplo_len)` | Computes row and column scalings to equilibrate a symmetric positive definite band matrix and reduce its condition number. |

`spbrfs_(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | Improves the computed solution to a symmetric positive definite banded system of linear equations AX=B, and provides forward and backward error bounds for the solution. |

`spbstf_(uplo, n, kd, ab, ldab, info, uplo_len)` | Computes a split Cholesky factorization of a real symmetric positive definite band matrix. |

`spbsvx_(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len, equed_len)` | Solves a symmetric positive definite banded system of linear equations AX=B, and provides an estimate of the condition number and error bounds on the solution. |

`spbsv_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | Solves a symmetric positive definite banded system of linear equations AX=B. |

`spbtrf_(uplo, n, kd, ab, ldab, info, uplo_len)` | Computes the Cholesky factorization of a symmetric positive definite band matrix. |

`spbtrs_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | Solves a symmetric positive definite banded system of linear equations AX=B, using the Cholesky factorization computed by SPBTRF. |

`spocon_(uplo, n, a, lda, anorm, rcond, work, iwork, info, uplo_len)` | Estimates the reciprocal of the condition number of a symmetric positive definite matrix, using the Cholesky factorization computed by SPOTRF. |

`spoequ_(n, a, lda, s, scond, amax, info)` | Computes row and column scalings to equilibrate a symmetric positive definite matrix and reduce its condition number. |

`sporfs_(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | Improves the computed solution to a symmetric positive definite system of linear equations AX=B, and provides forward and backward error bounds for the solution. |

`sposvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len, equed_len)` | Solves a symmetric positive definite system of linear equations AX=B, and provides an estimate of the condition number and error bounds on the solution. |

`sposv_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | Solves a symmetric positive definite system of linear equations AX=B. |

`spotrf_(uplo, n, a, lda, info, uplo_len)` | Computes the Cholesky factorization of a symmetric positive definite matrix. |

`spotri_(uplo, n, a, lda, info, uplo_len)` | Computes the inverse of a symmetric positive definite matrix, using the Cholesky factorization computed by SPOTRF. |

`spotrs_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | Solves a symmetric positive definite system of linear equations AX=B, using the Cholesky factorization computed by SPOTRF. |

`sppcon_(uplo, n, ap, anorm, rcond, work, iwork, info, uplo_len)` | Estimates the reciprocal of the condition number of a symmetric positive definite matrix in packed storage, using the Cholesky factorization computed by SPPTRF. |

`sppequ_(uplo, n, ap, s, scond, amax, info, uplo_len)` | Computes row and column scalings to equilibrate a symmetric positive definite matrix in packed storage and reduce its condition number. |

`spprfs_(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | Improves the computed solution to a symmetric positive definite system of linear equations AX=B, where A is held in packed storage, and provides forward and backward error bounds for the solution. |

`sppsvx_(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len, equed_len)` | Solves a symmetric positive definite system of linear equations AX=B, where A is held in packed storage, and provides an estimate of the condition number and error bounds on the solution. |

`sppsv_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | Solves a symmetric positive definite system of linear equations AX=B, where A is held in packed storage. |

`spptrf_(uplo, n, ap, info, uplo_len)` | Computes the Cholesky factorization of a symmetric positive definite matrix in packed storage. |

`spptri_(uplo, n, ap, info, uplo_len)` | Computes the inverse of a symmetric positive definite matrix in packed storage, using the Cholesky factorization computed by SPPTRF. |

`spptrs_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | Solves a symmetric positive definite system of linear equations AX=B, where A is held in packed storage, using the Cholesky factorization computed by SPPTRF. |

`sptcon_(n, d, e, anorm, rcond, work, info)` | Computes the reciprocal of the condition number of a symmetric positive definite tridiagonal matrix, using the LDL**H factorization computed by SPTTRF. |

`spteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | Computes all eigenvalues and eigenvectors of a real symmetric positive definite tridiagonal matrix, by computing the SVD of its bidiagonal Cholesky factor. |

`sptrfs_(n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, info)` | Improves the computed solution to a symmetric positive definite tridiagonal system of linear equations AX=B, and provides forward and backward error bounds for the solution. |

`sptsvx_(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info, fact_len)` | Solves a symmetric positive definite tridiagonal system of linear equations AX=B, and provides an estimate of the condition number and error bounds on the solution. |

`sptsv_(n, nrhs, d, e, b, ldb, info)` | Solves a symmetric positive definite tridiagonal system of linear equations AX=B. |

`spttrf_(n, d, e, info)` | Computes the LDL**H factorization of a symmetric positive definite tridiagonal matrix. |

`spttrs_(n, nrhs, d, e, b, ldb, info)` | Solves a symmetric positive definite tridiagonal system of linear equations, using the LDL**H factorization computed by SPTTRF. |

`ssbevd_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric band matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`ssbevx_(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues and eigenvectors of a symmetric band matrix. |

`ssbev_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, info, jobz_len, uplo_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric band matrix. |

`ssbgst_(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, info, vect_len, uplo_len)` | Reduces a real symmetric-definite banded generalized eigenproblem A x = lambda B x to standard form, where B has been factorized by SPBSTF (Crawford's algorithm). |

`ssbgvd_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. A and B are assumed to be symmetric and banded, and B is also positive definite. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`ssbgvx_(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. A and B are assumed to be symmetric and banded, and B is also positive definite. |

`ssbgv_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, info, jobz_len, uplo_len)` | Computes all the eigenvalues, and optionally, the eigenvectors of a real generalized symmetric-definite banded eigenproblem, of the form A*x=(lambda)*B*x. A and B are assumed to be symmetric and banded, and B is also positive definite. |

`ssbtrd_(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info, vect_len, uplo_len)` | Reduces a symmetric band matrix to real symmetric tridiagonal form by an orthogonal similarity transformation. |

`sspcon_(uplo, n, ap, ipiv, anorm, rcond, work, iwork, info, uplo_len)` | Estimates the reciprocal of the condition number of a real symmetric indefinite matrix in packed storage, using the factorization computed by SSPTRF. |

`sspevd_(jobz, uplo, n, ap, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric matrix in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`sspevx_(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues and eigenvectors of a symmetric matrix in packed storage. |

`sspev_(jobz, uplo, n, ap, w, z, ldz, work, info, jobz_len, uplo_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric matrix in packed storage. |

`sspgst_(itype, uplo, n, ap, bp, info, uplo_len)` | Reduces a symmetric-definite generalized eigenproblem Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, to standard form, where A and B are held in packed storage, and B has been factorized by SPPTRF. |

`sspgvd_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and eigenvectors of a generalized symmetric-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, where A and B are in packed storage. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`sspgvx_(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, eigenvectors of a generalized symmetric-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, where A and B are in packed storage. |

`sspgv_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, info, jobz_len, uplo_len)` | Computes all eigenvalues and eigenvectors of a generalized symmetric-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, where A and B are in packed storage. |

`ssprfs_(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | Improves the computed solution to a real symmetric indefinite system of linear equations AX=B, where A is held in packed storage, and provides forward and backward error bounds for the solution. |

`sspsvx_(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info, fact_len, uplo_len)` | Solves a real symmetric indefinite system of linear equations AX=B, where A is held in packed storage, and provides an estimate of the condition number and error bounds on the solution. |

`sspsv_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | Solves a real symmetric indefinite system of linear equations AX=B, where A is held in packed storage. |

`ssptrd_(uplo, n, ap, d, e, tau, info, uplo_len)` | Reduces a symmetric matrix in packed storage to real symmetric tridiagonal form by an orthogonal similarity transformation. |

`ssptrf_(uplo, n, ap, ipiv, info, uplo_len)` | Computes the factorization of a real symmetric-indefinite matrix in packed storage, using the diagonal pivoting method. |

`ssptri_(uplo, n, ap, ipiv, work, info, uplo_len)` | Computes the inverse of a real symmetric indefinite matrix in packed storage, using the factorization computed by SSPTRF. |

`ssptrs_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | Solves a real symmetric indefinite system of linear equations AX=B, where A is held in packed storage, using the factorization computed by SSPTRF. |

`sstebz_(range, order, n, vl, vu, il, iu, abstol, d, e, m, nsplit, w, iblock, isplit, work, iwork, info, range_len, order_len)` | Computes selected eigenvalues of a real symmetric tridiagonal matrix by bisection. |

`sstedc_(compz, n, d, e, z, ldz, work, lwork, iwork, liwork, info, compz_len)` | Computes all eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix using the divide and conquer algorithm. |

`sstegr_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len)` | Computes selected eigenvalues and, optionally, eigenvectors of a symmetric tridiagonal matrix. The eigenvalues are computed by the dqds algorithm, while eigenvectors are computed from various "good" LDL^T representations (also known as Relatively Robust Representations.) |

`sstein_(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)` | Computes selected eigenvectors of a real symmetric tridiagonal matrix by inverse iteration. |

`ssteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | Computes all eigenvalues and eigenvectors of a real symmetric tridiagonal matrix, using the implicit QL or QR algorithm. |

`ssterf_(n, d, e, info)` | Computes all eigenvalues of a real symmetric tridiagonal matrix, using a root-free variant of the QL or QR algorithm. |

`sstevd_(jobz, n, d, e, z, ldz, work, lwork, iwork, liwork, info, jobz_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric tridiagonal matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`sstevr_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len)` | Computes selected eigenvalues, and optionally, eigenvectors of a real symmetric tridiagonal matrix. Eigenvalues are computed by the dqds algorithm, and eigenvectors are computed from various "good" LDL^T representations (also known as Relatively Robust Representations). |

`sstevx_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, work, iwork, ifail, info, jobz_len, range_len)` | Computes selected eigenvalues and eigenvectors of a real symmetric tridiagonal matrix. |

`sstev_(jobz, n, d, e, z, ldz, work, info, jobz_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric tridiagonal matrix. |

`ssycon_(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info, uplo_len)` | Estimates the reciprocal of the condition number of a real symmetric indefinite matrix, using the factorization computed by SSYTRF. |

`ssyevd_(jobz, uplo, n, a, lda, w, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric matrix. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`ssyevr_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, eigenvectors of a real symmetric matrix. Eigenvalues are computed by the dqds algorithm, and eigenvectors are computed from various "good" LDL^T representations (also known as Relatively Robust Representations). |

`ssyevx_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues and eigenvectors of a symmetric matrix. |

`ssyev_(jobz, uplo, n, a, lda, w, work, lwork, info, jobz_len, uplo_len)` | Computes all eigenvalues, and optionally, eigenvectors of a real symmetric matrix. |

`ssygst_(itype, uplo, n, a, lda, b, ldb, info, uplo_len)` | Reduces a symmetric-definite generalized eigenproblem Ax= lambda Bx, ABx= lambda x, or BAx= lambda x, to standard form, where B has been factorized by SPOTRF. |

`ssygvd_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, iwork, liwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and the eigenvectors of a generalized symmetric-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x. If eigenvectors are desired, it uses a divide and conquer algorithm. |

`ssygvx_(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | Computes selected eigenvalues, and optionally, the eigenvectors of a generalized symmetric-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x. |

`ssygv_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, info, jobz_len, uplo_len)` | Computes all eigenvalues and the eigenvectors of a generalized symmetric-definite generalized eigenproblem, Ax= lambda Bx, ABx= lambda x, or BAx= lambda x. |

`ssyrfs_(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len)` | Improves the computed solution to a real symmetric indefinite system of linear equations AX=B, and provides forward and backward error bounds for the solution. |

`ssysvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, iwork, info, fact_len, uplo_len)` | Solves a real symmetric indefinite system of linear equations AX=B, and provides an estimate of the condition number and error bounds on the solution. |

`ssysv_(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info, uplo_len)` | Solves a real symmetric indefinite system of linear equations AX=B. |

`ssytrd_(uplo, n, a, lda, d, e, tau, work, lwork, info, uplo_len)` | Reduces a symmetric matrix to real symmetric tridiagonal form by an orthogonal similarity transformation. |

`ssytrf_(uplo, n, a, lda, ipiv, work, lwork, info, uplo_len)` | Computes the factorization of a real symmetric-indefinite matrix, using the diagonal pivoting method. |

`ssytri_(uplo, n, a, lda, ipiv, work, info, uplo_len)` | Computes the inverse of a real symmetric indefinite matrix, using the factorization computed by SSYTRF. |

`ssytrs_(uplo, n, nrhs, a, lda, ipiv, b, ldb, info, uplo_len)` | Solves a real symmetric indefinite system of linear equations AX=B, using the factorization computed by SSPTRF. |

`stbcon_(norm, uplo, diag, n, kd, ab, ldab, rcond, work, iwork, info, norm_len, uplo_len, diag_len)` | Estimates the reciprocal of the condition number of a triangular band matrix, in either the 1-norm or the infinity-norm. |

`stbrfs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len, trans_len, diag_len)` | Provides forward and backward error bounds for the solution of a triangular banded system of linear equations AX=B, A**T X=B or A**H X=B. |

`stbtrs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len, trans_len, diag_len)` | Solves a triangular banded system of linear equations AX=B, A**T X=B or A**H X=B. |

`stgevc_(side, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, mm, m, work, info, side_len, howmny_len)` | Computes some or all of the right and/or left generalized eigenvectors of a pair of upper triangular matrices. |

`stgexc_(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, work, lwork, info)` | Reorders the generalized real Schur decomposition of a real matrix pair (A,B) using an orthogonal equivalence transformation so that the diagonal block of (A,B) with row index IFST is moved to row ILST. |

`stgsen_(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphar, alphai, betav, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)` | Reorders the generalized real Schur decomposition of a real matrix pair (A, B) so that a selected cluster of eigenvalues appears in the leading diagonal blocks of the upper quasi-triangular matrix A and the upper triangular B. |

`stgsja_(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alphav, betav, u, ldu, v, ldv, q, ldq, work, ncycle, info, jobu_len, jobv_len, jobq_len)` | Computes the generalized singular value decomposition of two real upper triangular (or trapezoidal) matrices as output by SGGSVP. |

`stgsna_(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info, job_len, howmny_len)` | Estimates reciprocal condition numbers for specified eigenvalues and/or eigenvectors of a matrix pair (A, B) in generalized real Schur canonical form, as returned by SGGES. |

`stgsyl_(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info, trans_len)` | Solves the generalized Sylvester equation. |

`stpcon_(norm, uplo, diag, n, ap, rcond, work, iwork, info, norm_len, uplo_len, diag_len)` | Estimates the reciprocal of the condition number of a triangular matrix in packed storage, in either the 1-norm or the infinity-norm. |

`stprfs_(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len, trans_len, diag_len)` | Provides forward and backward error bounds for the solution of a triangular system of linear equations AX=B, A**T X=B or A**H X=B, where A is held in packed storage. |

`stptri_(uplo, diag, n, ap, info, uplo_len, diag_len)` | Computes the inverse of a triangular matrix in packed storage. |

`stptrs_(uplo, trans, diag, n, nrhs, ap, b, ldb, info, uplo_len, trans_len, diag_len)` | Solves a triangular system of linear equations AX=B, A**T X=B or A**H X=B, where A is held in packed storage. |

`strcon_(norm, uplo, diag, n, a, lda, rcond, work, iwork, info, norm_len, uplo_len, diag_len)` | Estimates the reciprocal of the condition number of a triangular matrix, in either the 1-norm or the infinity-norm. |

`strevc_(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, info, side_len, howmny_len)` | Computes some or all of the right and/or left eigenvectors of an upper quasi-triangular matrix. |

`strexc_(compq, n, t, ldt, q, ldq, ifst, ilst, work, info, compq_len)` | Reorders the Schur factorization of a matrix by an orthogonal similarity transformation. |

`strrfs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, iwork, info, uplo_len, trans_len, diag_len)` | Provides forward and backward error bounds for the solution of a triangular system of linear equations A X=B, A**T X=B or A**H X=B. |

`strsen_(job, compq, select, n, t, ldt, q, ldq, wr, wi, m, s, sep, work, lwork, iwork, liwork, info, job_len, compq_len)` | Reorders the Schur factorization of a matrix in order to find an orthonormal basis of a right invariant subspace corresponding to selected eigenvalues, and returns reciprocal condition numbers (sensitivities) of the average of the cluster of eigenvalues and of the invariant subspace. |

`strsna_(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, iwork, info, job_len, howmny_len)` | Estimates the reciprocal condition numbers (sensitivities) of selected eigenvalues and eigenvectors of an upper quasi-triangular matrix. |

`strsyl_(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info, trana_len, tranb_len)` | Solves the Sylvester matrix equation A X +/- X B=C where A and B are upper quasi-triangular, and may be transposed. |

`strtri_(uplo, diag, n, a, lda, info, uplo_len, diag_len)` | Computes the inverse of a triangular matrix. |

`strtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info, uplo_len, trans_len, diag_len)` | Solves a triangular system of linear equations AX=B, A**T X=B or A**H X=B. |

`stzrqf_(m, n, a, lda, tau, info)` | Computes an RQ factorization of an upper trapezoidal matrix. |

`stzrzf_(m, n, a, lda, tau, work, lwork, info)` | Computes an RZ factorization of an upper trapezoidal matrix (blocked version of STZRQF). |

`zbdsqr_(uplo, n, ncvt, nru, ncc, d, e, vt, ldvt, u, ldu, c, ldc, rwork, info, uplo_len)` | |

`zgbbrd_(vect, m, n, ncc, kl, ku, ab, ldab, d, e, q, ldq, pt, ldpt, c, ldc, work, rwork, info, vect_len)` | |

`zgbcon_(norm, n, kl, ku, ab, ldab, ipiv, anorm, rcond, work, rwork, info, norm_len)` | |

`zgbequ_(m, n, kl, ku, ab, ldab, r, c, rowcnd, colcnd, amax, info)` | |

`zgbrfs_(trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, trans_len)` | |

`zgbsvx_(fact, trans, n, kl, ku, nrhs, ab, ldab, afb, ldafb, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, trans_len, equed_len)` | |

`zgbsv_(n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info)` | |

`zgbtrf_(m, n, kl, ku, ab, ldab, ipiv, info)` | |

`zgbtrs_(trans, n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info, trans_len)` | |

`zgebak_(job, side, n, ilo, ihi, scale, m, v, ldv, info, job_len, side_len)` | |

`zgebal_(job, n, a, lda, ilo, ihi, scale, info, job_len)` | |

`zgebrd_(m, n, a, lda, d, e, tauq, taup, work, lwork, info)` | |

`zgecon_(norm, n, a, lda, anorm, rcond, work, rwork, info, norm_len)` | |

`zgeequ_(m, n, a, lda, r, c, rowcnd, colcnd, amax, info)` | |

`zgeesx_(jobvs, sort, select, sense, n, a, lda, sdim, w, vs, ldvs, rconde, rcondv, work, lwork, rwork, bwork, info, jobvs_len, sort_len, sense_len)` | |

`zgees_(jobvs, sort, select, n, a, lda, sdim, w, vs, ldvs, work, lwork, rwork, bwork, info, jobvs_len, sort_len)` | |

`zgeevx_(balanc, jobvl, jobvr, sense, n, a, lda, w, vl, ldvl, vr, ldvr, ilo, ihi, scale, abnrm, rconde, rcondv, work, lwork, rwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | |

`zgeev_(jobvl, jobvr, n, a, lda, w, vl, ldvl, vr, ldvr, work, lwork, rwork, info, jobvl_len, jobvr_len)` | |

`zgegs_(jobvsl, jobvsr, n, a, lda, b, ldb, alphav, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, info, jobvsl_len, jobvsr_len)` | |

`zgegv_(jobvl, jobvr, n, a, lda, b, ldb, alphar, betav, vl, ldvl, vr, ldvr, work, lwork, rwork, info, jobvl_len, jobvr_len)` | |

`zgehrd_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | |

`zgelqf_(m, n, a, lda, tau, work, lwork, info)` | |

`zgelsd_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, iwork, info)` | |

`zgelss_(m, n, nrhs, a, lda, b, ldb, s, rcond, rank, work, lwork, rwork, info)` | |

`zgelsx_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, rwork, info)` | |

`zgelsy_(m, n, nrhs, a, lda, b, ldb, jpvt, rcond, rank, work, lwork, rwork, info)` | |

`zgels_(trans, m, n, nrhs, a, lda, b, ldb, work, lwork, info, trans_len)` | |

`zgeqlf_(m, n, a, lda, tau, work, lwork, info)` | |

`zgeqp3_(m, n, a, lda, jpvt, tau, work, lwork, rwork, info)` | |

`zgeqpf_(m, n, a, lda, jpvt, tau, work, rwork, info)` | |

`zgeqrf_(m, n, a, lda, tau, work, lwork, info)` | |

`zgerfs_(trans, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, trans_len)` | |

`zgerqf_(m, n, a, lda, tau, work, lwork, info)` | |

`zgesdd_(jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, iwork, info, jobz_len)` | |

`zgesvd_(jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info, jobu_len, jobvt_len)` | |

`zgesvx_(fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, trans_len, equed_len)` | |

`zgesv_(n, nrhs, a, lda, ipiv, b, ldb, info)` | |

`zgetrf_(m, n, a, lda, ipiv, info)` | |

`zgetri_(n, a, lda, ipiv, work, lwork, info)` | |

`zgetrs_(trans, n, nrhs, a, lda, ipiv, b, ldb, info, trans_len)` | |

`zggbak_(job, side, n, ilo, ihi, lscale, rscale, m, v, ldv, info, job_len, side_len)` | |

`zggbal_(job, n, a, lda, b, ldb, ilo, ihi, lscale, rscale, work, info, job_len)` | |

`zggesx_(jobvsl, jobvsr, sort, delctg, sense, n, a, lda, b, ldb, sdim, alphav, betav, vsl, ldvsl, vsr, ldvsr, rconde, rcondv, work, lwork, rwork, iwork, liwork, bwork, info, jobvsl_len, jobvsr_len, sort_len, sense_len)` | |

`zgges_(jobvsl, jobvsr, sort, delctg, n, a, lda, b, ldb, sdim, alphav, betav, vsl, ldvsl, vsr, ldvsr, work, lwork, rwork, bwork, info, jobvsl_len, jobvsr_len, sort_len)` | |

`zggevx_(balanc, jobvl, jobvr, sense, n, a, lda, b, ldb, alphav, betav, vl, ldvl, vr, ldvr, ilo, ihi, lscale, rscale, abnrm, bbnrm, rconde, rcondv, work, lwork, rwork, iwork, bwork, info, balanc_len, jobvl_len, jobvr_len, sense_len)` | |

`zggev_(jobvl, jobvr, n, a, lda, b, ldb, alphav, betav, vl, ldvl, vr, ldvr, work, lwork, rwork, info, jobvl_len, jobvr_len)` | |

`zggglm_(n, m, p, a, lda, b, ldb, d, x, y, work, lwork, info)` | |

`zgghrd_(compq, compz, n, ilo, ihi, a, lda, b, ldb, q, ldq, z, ldz, info, compq_len, compz_len)` | |

`zgglse_(m, n, p, a, lda, b, ldb, c, d, x, work, lwork, info)` | |

`zggqrf_(n, m, p, a, lda, taua, b, ldb, taub, work, lwork, info)` | |

`zggrqf_(m, p, n, a, lda, taua, b, ldb, taub, work, lwork, info)` | |

`zggsvd_(jobu, jobv, jobq, m, n, p, k, l, a, lda, b, ldb, alphav, betav, u, ldu, v, ldv, q, ldq, work, rwork, iwork, info, jobu_len, jobv_len, jobq_len)` | |

`zggsvp_(jobu, jobv, jobq, m, p, n, a, lda, b, ldb, tola, tolb, k, l, u, ldu, v, ldv, q, ldq, iwork, rwork, tau, work, info, jobu_len, jobv_len, jobq_len)` | |

`zgtcon_(norm, n, dl, d, du, du2, ipiv, anorm, rcond, work, info, norm_len)` | |

`zgtrfs_(trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, trans_len)` | |

`zgtsvx_(fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, trans_len)` | |

`zgtsv_(n, nrhs, dl, d, du, b, ldb, info)` | |

`zgttrf_(n, dl, d, du, du2, ipiv, info)` | |

`zgttrs_(trans, n, nrhs, dl, d, du, du2, ipiv, b, ldb, info, trans_len)` | |

`zhbevd_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`zhbevx_(jobz, range, uplo, n, kd, ab, ldab, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`zhbev_(jobz, uplo, n, kd, ab, ldab, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | |

`zhbgst_(vect, uplo, n, ka, kb, ab, ldab, bb, ldbb, x, ldx, work, rwork, info, vect_len, uplo_len)` | |

`zhbgvd_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`zhbgvx_(jobz, range, uplo, n, ka, kb, ab, ldab, bb, ldbb, q, ldq, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`zhbgv_(jobz, uplo, n, ka, kb, ab, ldab, bb, ldbb, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | |

`zhbtrd_(vect, uplo, n, kd, ab, ldab, d, e, q, ldq, work, info, vect_len, uplo_len)` | |

`zhecon_(uplo, n, a, lda, ipiv, anorm, rcond, work, info, uplo_len)` | |

`zheevd_(jobz, uplo, n, a, lda, w, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`zheevr_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, range_len, uplo_len)` | |

`zheevx_(jobz, range, uplo, n, a, lda, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`zheev_(jobz, uplo, n, a, lda, w, work, lwork, rwork, info, jobz_len, uplo_len)` | |

`zhegst_(itype, uplo, n, a, lda, b, ldb, info, uplo_len)` | |

`zhegvd_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`zhegvx_(itype, jobz, range, uplo, n, a, lda, b, ldb, vl, vu, il, iu, abstol, m, w, z, ldz, work, lwork, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`zhegv_(itype, jobz, uplo, n, a, lda, b, ldb, w, work, lwork, rwork, info, jobz_len, uplo_len)` | |

`zherfs_(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zhesvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info, fact_len, uplo_len)` | |

`zhesv_(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info, uplo_len)` | |

`zhetrd_(uplo, n, a, lda, d, e, tau, work, lwork, info, uplo_len)` | |

`zhetrf_(uplo, n, a, lda, ipiv, work, lwork, info, uplo_len)` | |

`zhetri_(uplo, n, a, lda, ipiv, work, info, uplo_len)` | |

`zhetrs_(uplo, n, nrhs, a, lda, ipiv, b, ldb, info, uplo_len)` | |

`zhgeqz_(job, compq, compz, n, ilo, ihi, a, lda, b, ldb, alphav, betav, q, ldq, z, ldz, work, lwork, rwork, info, job_len, compq_len, compz_len)` | |

`zhpcon_(uplo, n, ap, ipiv, anorm, rcond, work, info, uplo_len)` | |

`zhpevd_(jobz, uplo, n, ap, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`zhpevx_(jobz, range, uplo, n, ap, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`zhpev_(jobz, uplo, n, ap, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | |

`zhpgst_(itype, uplo, n, ap, bp, info, uplo_len)` | |

`zhpgvd_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, jobz_len, uplo_len)` | |

`zhpgvx_(itype, jobz, range, uplo, n, ap, bp, vl, vu, il, iu, abstol, m, w, z, ldz, work, rwork, iwork, ifail, info, jobz_len, range_len, uplo_len)` | |

`zhpgv_(itype, jobz, uplo, n, ap, bp, w, z, ldz, work, rwork, info, jobz_len, uplo_len)` | |

`zhprfs_(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zhpsvx_(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len)` | |

`zhpsv_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`zhptrd_(uplo, n, ap, d, e, tau, info, uplo_len)` | |

`zhptrf_(uplo, n, ap, ipiv, info, uplo_len)` | |

`zhptri_(uplo, n, ap, ipiv, work, info, uplo_len)` | |

`zhptrs_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`zhsein_(side, eigsrc, initv, select, n, h, ldh, w, vl, ldvl, vr, ldvr, mm, m, work, rwork, ifaill, ifailr, info, side_len, eigsrc_len, initv_len)` | |

`zhseqr_(job, compz, n, ilo, ihi, h, ldh, w, z, ldz, work, lwork, info, job_len, compz_len)` | |

`zpbcon_(uplo, n, kd, ab, ldab, anorm, rcond, work, rwork, info, uplo_len)` | |

`zpbequ_(uplo, n, kd, ab, ldab, s, scond, amax, info, uplo_len)` | |

`zpbrfs_(uplo, n, kd, nrhs, ab, ldab, afb, ldafb, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zpbstf_(uplo, n, kd, ab, ldab, info, uplo_len)` | |

`zpbsvx_(fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len, equed_len)` | |

`zpbsv_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | |

`zpbtrf_(uplo, n, kd, ab, ldab, info, uplo_len)` | |

`zpbtrs_(uplo, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len)` | |

`zpocon_(uplo, n, a, lda, anorm, rcond, work, rwork, info, uplo_len)` | |

`zpoequ_(n, a, lda, s, scond, amax, info)` | |

`zporfs_(uplo, n, nrhs, a, lda, af, ldaf, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zposvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len, equed_len)` | |

`zposv_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | |

`zpotrf_(uplo, n, a, lda, info, uplo_len)` | |

`zpotri_(uplo, n, a, lda, info, uplo_len)` | |

`zpotrs_(uplo, n, nrhs, a, lda, b, ldb, info, uplo_len)` | |

`zppcon_(uplo, n, ap, anorm, rcond, work, rwork, info, uplo_len)` | |

`zppequ_(uplo, n, ap, s, scond, amax, info, uplo_len)` | |

`zpprfs_(uplo, n, nrhs, ap, afp, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zppsvx_(fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len, equed_len)` | |

`zppsv_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | |

`zpptrf_(uplo, n, ap, info, uplo_len)` | |

`zpptri_(uplo, n, ap, info, uplo_len)` | |

`zpptrs_(uplo, n, nrhs, ap, b, ldb, info, uplo_len)` | |

`zptcon_(n, d, e, anorm, rcond, rwork, info)` | |

`zpteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | |

`zptrfs_(uplo, n, nrhs, d, e, df, ef, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zptsvx_(fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len)` | |

`zptsv_(n, nrhs, d, e, b, ldb, info)` | |

`zpttrf_(n, d, e, info)` | |

`zpttrs_(uplo, n, nrhs, d, e, b, ldb, info, uplo_len)` | |

`zspcon_(uplo, n, ap, ipiv, anorm, rcond, work, info, uplo_len)` | |

`zsprfs_(uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zspsvx_(fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info, fact_len, uplo_len)` | |

`zspsv_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`zsptrf_(uplo, n, ap, ipiv, info, uplo_len)` | |

`zsptri_(uplo, n, ap, ipiv, work, info, uplo_len)` | |

`zsptrs_(uplo, n, nrhs, ap, ipiv, b, ldb, info, uplo_len)` | |

`zstedc_(compz, n, d, e, z, ldz, work, lwork, rwork, lrwork, iwork, liwork, info, compz_len)` | |

`zstegr_(jobz, range, n, d, e, vl, vu, il, iu, abstol, m, w, z, ldz, isuppz, work, lwork, iwork, liwork, info, jobz_len, range_len)` | |

`zstein_(n, d, e, m, w, iblock, isplit, z, ldz, work, iwork, ifail, info)` | |

`zsteqr_(compz, n, d, e, z, ldz, work, info, compz_len)` | |

`zsycon_(uplo, n, a, lda, ipiv, anorm, rcond, work, info, uplo_len)` | |

`zsyrfs_(uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len)` | |

`zsysvx_(fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info, fact_len, uplo_len)` | |

`zsysv_(uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info, uplo_len)` | |

`zsytrf_(uplo, n, a, lda, ipiv, work, lwork, info, uplo_len)` | |

`zsytri_(uplo, n, a, lda, ipiv, work, info, uplo_len)` | |

`zsytrs_(uplo, n, nrhs, a, lda, ipiv, b, ldb, info, uplo_len)` | |

`ztbcon_(norm, uplo, diag, n, kd, ab, ldab, rcond, work, rwork, info, norm_len, uplo_len, diag_len)` | |

`ztbrfs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len, trans_len, diag_len)` | |

`ztbtrs_(uplo, trans, diag, n, kd, nrhs, ab, ldab, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`ztgevc_(side, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, mm, m, work, rwork, info, side_len, howmny_len)` | |

`ztgexc_(wantq, wantz, n, a, lda, b, ldb, q, ldq, z, ldz, ifst, ilst, info)` | |

`ztgsen_(ijob, wantq, wantz, select, n, a, lda, b, ldb, alphav, betav, q, ldq, z, ldz, m, pl, pr, dif, work, lwork, iwork, liwork, info)` | |

`ztgsja_(jobu, jobv, jobq, m, p, n, k, l, a, lda, b, ldb, tola, tolb, alphav, betav, u, ldu, v, ldv, q, ldq, work, ncycle, info, jobu_len, jobv_len, jobq_len)` | |

`ztgsna_(job, howmny, select, n, a, lda, b, ldb, vl, ldvl, vr, ldvr, s, dif, mm, m, work, lwork, iwork, info, job_len, howmny_len)` | |

`ztgsyl_(trans, ijob, m, n, a, lda, b, ldb, c, ldc, d, ldd, e, lde, f, ldf, scale, dif, work, lwork, iwork, info, trans_len)` | |

`ztpcon_(norm, uplo, diag, n, ap, rcond, work, rwork, info, norm_len, uplo_len, diag_len)` | |

`ztprfs_(uplo, trans, diag, n, nrhs, ap, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len, trans_len, diag_len)` | |

`ztptri_(uplo, diag, n, ap, info, uplo_len, diag_len)` | |

`ztptrs_(uplo, trans, diag, n, nrhs, ap, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`ztrcon_(norm, uplo, diag, n, a, lda, rcond, work, rwork, info, norm_len, uplo_len, diag_len)` | |

`ztrevc_(side, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, mm, m, work, rwork, info, side_len, howmny_len)` | |

`ztrexc_(compq, n, t, ldt, q, ldq, ifst, ilst, info, compq_len)` | |

`ztrrfs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, x, ldx, ferr, berr, work, rwork, info, uplo_len, trans_len, diag_len)` | |

`ztrsen_(job, compq, select, n, t, ldt, q, ldq, w, m, s, sep, work, lwork, info, job_len, compq_len)` | |

`ztrsna_(job, howmny, select, n, t, ldt, vl, ldvl, vr, ldvr, s, sep, mm, m, work, ldwork, rwork, info, job_len, howmny_len)` | |

`ztrsyl_(trana, tranb, isgn, m, n, a, lda, b, ldb, c, ldc, scale, info, trana_len, tranb_len)` | |

`ztrtri_(uplo, diag, n, a, lda, info, uplo_len, diag_len)` | |

`ztrtrs_(uplo, trans, diag, n, nrhs, a, lda, b, ldb, info, uplo_len, trans_len, diag_len)` | |

`ztzrqf_(m, n, a, lda, tau, info)` | |

`ztzrzf_(m, n, a, lda, tau, work, lwork, info)` | |

`zungbr_(vect, m, n, k, a, lda, tau, work, lwork, info, vect_len)` | |

`zunghr_(n, ilo, ihi, a, lda, tau, work, lwork, info)` | |

`zunglq_(m, n, k, a, lda, tau, work, lwork, info)` | |

`zungql_(m, n, k, a, lda, tau, work, lwork, info)` | |

`zungqr_(m, n, k, a, lda, tau, work, lwork, info)` | |

`zungrq_(m, n, k, a, lda, tau, work, lwork, info)` | |

`zungtr_(uplo, n, a, lda, tau, work, lwork, info, uplo_len)` | |

`zunmbr_(vect, side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, vect_len, side_len, trans_len)` | |

`zunmhr_(side, trans, m, n, ilo, ihi, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`zunmlq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`zunmql_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`zunmqr_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`zunmr3_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, info, side_len, trans_len)` | |

`zunmrq_(side, trans, m, n, k, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`zunmrz_(side, trans, m, n, k, l, a, lda, tau, c, ldc, work, lwork, info, side_len, trans_len)` | |

`zunmtr_(side, uplo, trans, m, n, a, lda, tau, c, ldc, work, lwork, info, side_len, uplo_len, trans_len)` | |

`zupgtr_(uplo, n, ap, tau, q, ldq, work, info, uplo_len)` | |

`zupmtr_(side, uplo, trans, m, n, ap, tau, c, ldc, work, info, side_len, uplo_len, trans_len)` |

## Aliases

Name | Type | Description |
---|---|---|

`FCB_CGEESX_SELECT` | `extern(C) int function(std` | |

`FCB_CGEES_SELECT` | `extern(C) int function(std` | |

`FCB_CGGESX_SELCTG` | `extern(C) int function(std` | |

`FCB_CGGES_SELCTG` | `extern(C) int function(std` | |

`FCB_DGEESX_SELECT` | `extern(C) int function(double*, double*)` | |

`FCB_DGEES_SELECT` | `extern(C) int function(double*, double*)` | |

`FCB_DGGESX_DELCTG` | `extern(C) int function(double*, double*, double*)` | |

`FCB_DGGES_DELCTG` | `extern(C) int function(double*, double*, double*)` | |

`FCB_SGEESX_SELECT` | `extern(C) int function(float*, float*)` | |

`FCB_SGEES_SELECT` | `extern(C) int function(float*, float*)` | |

`FCB_SGGESX_SELCTG` | `extern(C) int function(float*, float*, float*)` | |

`FCB_SGGES_SELCTG` | `extern(C) int function(float*, float*, float*)` | |

`FCB_ZGEESX_SELECT` | `extern(C) int function(std` | |

`FCB_ZGEES_SELECT` | `extern(C) int function(std` | |

`FCB_ZGGESX_DELCTG` | `extern(C) int function(std` | |

`FCB_ZGGES_DELCTG` | `extern(C) int function(std` | |

`f_cdouble` | `std` | |

`f_cfloat` | `std` | |

`f_double` | `double` | |

`f_float` | `float` | |

`f_int` | `int` | |

`lapack_float_ret_t` | `float` |