**?gesv**
computes the solution to the system of linear equations with a square matrix *A* and multiple right-hand sides.

```
call sgesv (
```

*n, nrhs, a, lda, ipiv, b, ldb, info*)

call dgesv (*n, nrhs, a, lda, ipiv, b, ldb, info*)

call cgesv (*n, nrhs, a, lda, ipiv, b, ldb, info*)

call zgesv (*n, nrhs, a, lda, ipiv, b, ldb, info*)

**?gesvx**
computes the solution to the system of linear equations with a square matrix *A* and multiple right-hand sides, and provides error bounds on the solution.

```
call sgesvx (
```

*fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call dgesvx (*fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call cgesvx (*fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zgesvx (*fact, trans, n, nrhs, a, lda, af, ldaf, ipiv, equed, r, c, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

**?gbsv**
computes the solution to the system of linear equations with a band matrix *A* and multiple right-hand sides.

```
call sgbsv (
```

*n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info*)

call dgbsv (*n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info*)

call cgbsv (*n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info*)

call zgbsv (*n, kl, ku, nrhs, ab, ldab, ipiv, b, ldb, info*)

**?gbsvx**
computes the solution to the real or complex system of linear equations with a band matrix *A* and multiple right-hand sides, and provides error bounds on the solution.

```
call 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*)

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

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

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

**?gtsv**
computes the solution to the system of linear equations with a tridiagonal matrix *A* and multiple right-hand sides.

```
call sgtsv (
```

*n, nrhs, dl, d, du, b, ldb, info*)

call dgtsv (*n, nrhs, dl, d, du, b, ldb, info*)

call cgtsv (*n, nrhs, dl, d, du, b, ldb, info*)

call zgtsv (*n, nrhs, dl, d, du, b, ldb, info*)

**?gtsvx**
computes the solution to the real or complex system of linear equations with a tridiagonal matrix *A* and multiple right-hand sides, and provides error bounds on the solution.

```
call sgtsvx (
```

*fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call dgtsvx (*fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call cgtsvx (*fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zgtsvx (*fact, trans, n, nrhs, dl, d, du, dlf, df, duf, du2, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

**?posv**
computes the solution to the system of linear equations with a symmetric or Hermitian positive definite matrix *A* and multiple right-hand sides.

```
call sposv (
```

*uplo, n, nrhs, a, lda, b, ldb, info*)

call dposv (*uplo, n, nrhs, a, lda, b, ldb, info*)

call cposv (*uplo, n, nrhs, a, lda, b, ldb, info*)

call zposv (*uplo, n, nrhs, a, lda, b, ldb, info*)

**?posvx**
uses the Cholesky factorization to compute the solution to the system of linear equations with a symmetric or Hermitian positive-definite matrix *A*, and provides error bounds on the solution.

```
call sposvx (
```

*fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call dposvx (*fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call cposvx (*fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zposvx (*fact, uplo, n, nrhs, a, lda, af, ldaf, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

**?ppsv**
computes the solution to the system of linear equations with a symmetric (Hermitian) positive-definite packed matrix *A* and multiple right-hand sides.

```
call sppsv (
```

*uplo, n, nrhs, ap, b, ldb, info*)

call dppsv (*uplo, n, nrhs, ap, b, ldb, info*)

call cppsv (*uplo, n, nrhs, ap, b, ldb, info*)

call zppsv (*uplo, n, nrhs, ap, b, ldb, info*)

**?ppsvx**
uses the Cholesky factorization to compute the solution to the system of linear equations with a symmetric (Hermitian) positive-definite packed matrix *A* and provides error bounds on the solution.

```
call sppsvx (
```

*fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call dppsvx (*fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call cppsvx (*fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zppsvx (*fact, uplo, n, nrhs, ap, afp, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

**?pbsv**
computes the solution to the system of linear equations with a symmetric or Hermitian positive-definite band
matrix *A* and multiple right-hand sides.

```
call spbsv (
```

*uplo, n, kd, nrhs, ab, ldab, b, ldb, info*)

call dpbsv (*uplo, n, kd, nrhs, ab, ldab, b, ldb, info*)

call cpbsv (*uplo, n, kd, nrhs, ab, ldab, b, ldb, info*)

call zpbsv (*uplo, n, kd, nrhs, ab, ldab, b, ldb, info*)

**?pbsvx**
uses the Cholesky factorization to compute the solution to the system of linear equations with a symmetric (Hermitian) positive-definite band matrix *A* and provides error bounds on the solution.

```
call spbsvx (
```

*fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call dpbsvx (*fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call cpbsvx (*fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zpbsvx (*fact, uplo, n, kd, nrhs, ab, ldab, afb, ldafb, equed, s, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

**?ptsv**
computes the solution to the system of linear equations with a symmetric or Hermitian positive-definite tridiagonal matrix *A* and multiple right-hand sides.

```
call sptsv (
```

*n, nrhs, d, e, b, ldb, info*)

call dptsv (*n, nrhs, d, e, b, ldb, info*)

call cptsv (*n, nrhs, d, e, b, ldb, info*)

call zptsv (*n, nrhs, d, e, b, ldb, info*)

**?ptsvx**
uses the factorization *A=LDL ^{H}* to compute
the solution to the system of linear equations with a symmetric (Hermitian) positive-definite tridiagonal matrix

```
call sptsvx (
```*fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info*)

call dptsvx (*fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, info*)

call cptsvx (*fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zptsvx (*fact, n, nrhs, d, e, df, ef, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

**?sysv**
computes the solution to the system of linear equations with a real or complex symmetric matrix *A* and multiple right-hand sides.

```
call ssysv (
```

*uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info*)

call dsysv (*uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info*)

call csysv (*uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info*)

call zsysv (*uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info*)

**?sysvx**
uses the diagonal pivoting factorization to compute the solution to the system of linear equations with a real or complex symmetric matrix *A* and provides error bounds on the solution.

```
call ssysvx (
```

*fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, iwork, info*)

call dsysvx (*fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, iwork, info*)

call csysvx (*fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info*)

call zsysvx (*fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info*)

**?hesv**
computes the solution to the system of linear equations with a Hermitian matrix *A* and multiple right-hand sides.

```
call chesv (
```

*uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info*)

call zhesv (*uplo, n, nrhs, a, lda, ipiv, b, ldb, work, lwork, info*)

**?hesvx**
uses the diagonal pivoting factorization to compute the solution to the complex system of linear equations with a Hermitian matrix *A* and provides error bounds on the solution.

```
call chesvx (
```

*fact, uplo, n, nrhs, a, lda, af, ldaf, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, lwork, rwork, info*)

call zhesvx (

**?spsv**
computes the solution to the system of linear equations with a real or complex symmetric matrix *A* stored in packed format, and multiple right-hand sides.

```
call sspsv (
```

*uplo, n, nrhs, ap, ipiv, b, ldb, info*)

call dspsv (*uplo, n, nrhs, ap, ipiv, b, ldb, info*)

call cspsv (*uplo, n, nrhs, ap, ipiv, b, ldb, info*)

call zspsv (*uplo, n, nrhs, ap, ipiv, b, ldb, info*)

**?spsvx**
uses the diagonal pivoting factorization to compute the solution to the system of linear equations with a real or complex symmetric matrix *A* stored in packed format and provides error bounds on the solution.

```
call sspsvx (
```

*fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call dspsvx (*fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, iwork, info*)

call cspsvx (*fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zspsvx (*fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

**?hpsv**
computes the solution to the system of linear equations with a Hermitian matrix *A* stored in packed format, and multiple right-hand sides.

```
call chpsv (
```

*uplo, n, nrhs, ap, ipiv, b, ldb, info*)

call zhpsv (*uplo, n, nrhs, ap, ipiv, b, ldb, info*)

**?hpsvx**
uses the diagonal pivoting factorization to compute the solution to the system of linear equations with a Hermitian matrix *A* stored in packed format and provides error bounds on the solution.

```
call chpsvx (
```

*fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

call zhpsvx (*fact, uplo, n, nrhs, ap, afp, ipiv, b, ldb, x, ldx, rcond, ferr, berr, work, rwork, info*)

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