**?gemm**
performs a matrix-matrix operation

,
*c* := *alpha**op(*a*)*op(*b*) +
*beta***c*

where

is an
*c*

-by-*m*

matrix,
*n*

`op(`

is an
*a*)

-by-*m*

matrix,
*k*

`op(`

is a
*b*)

-by-*k*

matrix.
*n*

For the definition of `op(`

and *a*)`op(`

, see Matrix Arguments.
*b*)

```
call sgemm (
```

*transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

call dgemm (*transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

call cgemm (*transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

call zgemm (*transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

**?hemm**
performs one of the following matrix-matrix operations:

for *c* := *alpha***a***b* +
*beta***c*

=
*side*`'L'`

or`'l'`

for *c* := *alpha***b***a* +
*beta***c*

=
*side*`'R'`

or`'r'`

,

where

is a Hermitian matrix,
*a*

and *b*

are
*c*

-by-*m*

matrices.
*n*

```
call chemm (
```

*side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc*)

call zhemm (*side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc*)

**?herk**
performs a rank-*n* update of a Hermitian matrix, that is, one of the following operations:

for *c* :=
*alpha***a**conjug(*a*') +
*beta***c*

=
*trans*`'N'`

or`'n'`

for *c* :=
*alpha**conjug(*a*')**a*
+
*beta***c*

=
*trans*`'C'`

or`'c'`

,

where

is an
*c*

-by-*n*

Hermitian matrix;
*n*

is an
*a*

-by-*n*

matrix, if
*k*

=
*trans*`'N'`

or`'n'`

,

is a
*a*

-by-*k*

matrix, if
*n*

=
*trans*`'C'`

or`'c'`

.

```
call cherk (
```

*uplo, trans, n, k, alpha, a, lda, beta, c, ldc*)

call zherk (*uplo, trans, n, k, alpha, a, lda, beta, c, ldc*)

**?her2k**
performs a rank-2*k* update of an

-by-*n*

Hermitian matrix *n*

, that is, one of the following operations:*c*

,
for *c* :=
*alpha***a**conjg(*b*') + conjg(*alpha*)**b**conjg(*a*') + *beta***c*

=
*trans*`'N'`

or`'n'`

,
for *c* :=
*alpha**conjg(*b*')**a* + conjg(*alpha*)*conjg(*a*')**b* + *beta***c*

=
*trans*`'C'`

or`'c'`

where

is an
*c*

-by-*n*

Hermitian matrix;
*n*

and *a*

are
*b*

-by-*n*

matrices if
*k*

=
*trans*`'N'`

or`'n'`

,

and *a*

are
*b*

-by-*k*

matrices if
*n*

=
*trans*`'C'`

or`'c'`

.

```
call cher2k (
```

*uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

call zher2k (*uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

**?symm**
performs one of the following matrix-matrix operations using symmetric matrices:

for *c* := *alpha***a***b* +
*beta***c*

=
*side*`'L'`

or`'l'`

for *c* := *alpha***b***a* +
*beta***c*

=
*side*`'R'`

or`'r'`

,

where

is a symmetric matrix,
*a*

and *b*

are
*c*

-by-*m*

matrices.
*n*

```
call ssymm (
```

*side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc*)

call dsymm (*side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc*)

call csymm (*side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc*)

call zsymm (*side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc*)

**?syrk**
performs a rank-*n* update of an

-by-*n*

symmetric matrix *n*

, that is, one of the following operations:*c*

for *c* := *alpha***a***a*' +
*beta***c*

=
*trans*`'N'`

or`'n'`

for *c* := *alpha***a*'**a* +
*beta***c*

=
*trans*`'T'`

or`'t'`

,`'C'`

or`'c'`

,

where

is an
*c*

-by-*n*

symmetric matrix;
*n*

is an
*a*

-by-*n*

matrix, if
*k*

=
*trans*`'N'`

or`'n'`

,

is a
*a*

-by-*k*

matrix, if
*n*

=
*trans*`'T'`

or`'t'`

,`'C'`

or`'c'`

.

```
call ssyrk (
```

*uplo, trans, n, k, alpha, a, lda, beta, c, ldc*)

call dsyrk (*uplo, trans, n, k, alpha, a, lda, beta, c, ldc*)

call csyrk (*uplo, trans, n, k, alpha, a, lda, beta, c, ldc*)

call zsyrk (*uplo, trans, n, k, alpha, a, lda, beta, c, ldc*)

**?syr2k**
performs a rank-2*k* update of an

-by-*n*

symmetric matrix *n*

, that is, one of the following operations:*c*

for *c* := *alpha***a***b*' + *alpha***b***a*' +
*beta***c*

=
*trans*`'N'`

or`'n'`

for *c* := *alpha***a*'**b* + *alpha***b*'**a* +
*beta***c*

=
*trans*`'T'`

or`'t'`

,

where

is an
*c*

-by-*n*

symmetric matrix;
*n*

and *a*

are
*b*

-by-*n*

matrices, if
*k*

=
*trans*`'N'`

or`'n'`

,

and *a*

are
*b*

-by-*k*

matrices, if
*n*

=
*trans*`'T'`

or`'t'`

.

```
call ssyr2k (
```

*uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

call dsyr2k (*uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

call csyr2k (*uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

call zsyr2k (*uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc*)

**?trmm**
performs one of the matrix-matrix operations using triangular matrices:

for *b* := *alpha**op(*a*)**b*

=
*side*`'L'`

or`'l'`

for *b* := *alpha***b**op(*a*)

=
*side*`'R'`

or`'r'`

,

where

is an
*b*

-by-*m*

general matrix, and *n*

is triangular;
*a*

`op(`

must be an
*a*)

-by-*m*

matrix, if
*m*

=
*side*`'L'`

or`'l'`

`op(`

must be an
*a*)

-by-*n*

matrix, if
*n*

=
*side*`'R'`

or`'r'`

.

For the definition of `op(`

, see Matrix Arguments.
*a*)

```
call strmm (
```

*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

call dtrmm (*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

call ctrmm (*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

call ztrmm (*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

**?trsm**
solves one of the following matrix equations:

`op(`

or
*a*)**x* = *alpha***b*

,
*x**op(*a*) = *alpha***b*

where

and *x*

are
*b*

-by-*m*

general matrices, and *n*

is triangular;
*a*

`op(`

must be an
*a*)

-by-*m*

matrix, if
*m*

=
*side*`'L'`

or`'l'`

`op(`

must be an
*a*)

-by-*n*

matrix, if
*n*

=
*side*`'R'`

or`'r'`

.

For the definition of `op(`

, see Matrix Arguments.
*a*)

The routine overwrites

on *x*

.
*b*

```
call strsm (
```

*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

call dtrsm (*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

call ctrsm (*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

call ztrsm (*side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb*)

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