[ Previous |
Next |
Contents |
Glossary |
Home |
Search ]

*AIX Version 4.3 Base Operating System and Extensions Technical Reference, Volume 2*

## STRMM, DTRMM, CTRMM, or ZTRMM Subroutine

### Purpose

Performs matrix-matrix operations on triangular
matrices.

### Library

BLAS Library (**libblas.a**)

### FORTRAN Syntax

**SUBROUTINE** **STRMM(***SIDE***, ***UPLO***, ***TRANSA***, ***DIAG***,**
*M***, ***N***, ***ALPHA***, ***A***, ***LDA***, ***B***, ***LDB***)**
**CHARACTER*1** *SIDE***,***UPLO***,***TRANSA***,***DIAG*
**INTEGER** *M***,***N***,***LDA***,***LDB*
**REAL** *ALPHA*
**REAL** *A***(***LDA,****), ***B***(***LDB***,*)**

**SUBROUTINE** **DTRMM(***SIDE***, ***UPLO***, ***TRANSA***, ***DIAG***,**
*M***, ***N***, ***ALPHA***, ***A***, ***LDA***, ***B***, ***LDB***)**
**CHARACTER*1**
*SIDE***,***UPLO***,***TRANSA***,***DIAG*
**INTEGER** *M***,***N***,***LDA***,***LDB*
**DOUBLE PRECISION** *ALPHA*
**DOUBLE PRECISION** *A***(***LDA***,*), ***B***(***LDB***,*)**

**SUBROUTINE** **CTRMM(***SIDE***, ***UPLO***, ***TRANSA***, ***DIAG***,**
*M***, ***N***, ***ALPHA***, ***A***, ***LDA***, ***B***, ***LDB***)**
**CHARACTER*1**
*SIDE***,***UPLO***,***TRANSA***,***DIAG*
**INTEGER** *M***,***N***,***LDA***,***LDB*
**COMPLEX** *ALPHA*
**COMPLEX** *A***(***LDA***,*), ***B***(***LDB***,*)**

**SUBROUTINE** **ZTRMM(***SIDE***, ***UPLO***, ***TRANSA***, ***DIAG***,**
*M***, ***N***, ***ALPHA***, ***A***, ***LDA***, ***B***, ***LDB***)**
**CHARACTER*1**
*SIDE***,***UPLO***,***TRANSA***,***DIAG*
**INTEGER** *M***,***N***,***LDA***,***LDB*
**COMPLEX*16** *ALPHA*
**COMPLEX*16** *A***(***LDA***,*), ***B***(***LDB***,*)**

### Description

The **STRMM**, **DTRMM**, **CTRMM**,
or **ZTRMM** subroutine performs one of the matrix-matrix operations:

`B`` := alpha * op( ``A`` ) * ``B`

OR

`B`` := alpha * ``B`` * op( ``A`` )`

where alpha is a scalar, *B* is an *M* by
*N* matrix, A is a unit, or non-unit, upper or lower triangular matrix, and op(
*A* ) is either op( *A* ) = *A* or op( *A* ) = *A*'.

### Parameters

*SIDE* |
On entry, *SIDE* specifies whether op( *A* ) multiplies *B*
from the left or right as follows:
*SIDE* = 'L' or 'l' |
*B* := alpha * op( *A* ) * *B* |
*SIDE* = 'R' or 'r' |
*B* := alpha * *B ** op( *A* ) |
Unchanged on exit. |

*UPLO* |
On entry, *UPLO* specifies whether the matrix *A* is an upper or
lower triangular matrix as follows:
*UPLO* = 'U' or 'u' |
*A* is an upper triangular matrix. |
*UPLO* = 'L' or 'l' |
*A* is a lower triangular matrix. |
Unchanged on exit. |

*TRANSA* |
On entry, *TRANSA* specifies the form of op( *A* ) to be used in
the matrix multiplication as follows:
*TRANSA* = 'N' or 'n' |
op( *A* ) =* A* |
*TRANSA* = 'T' or 't' |
op( *A* ) = *A*' |
*TRANSA* = 'C' or 'c' |
op( *A* ) = *A*' |
Unchanged on exit. |

*DIAG* |
On entry, *DIAG* specifies whether or not *A* is unit triangular
as follows:
*DIAG* = 'U' or 'u' |
*A* is assumed to be unit triangular. |
*DIAG* = 'N' or 'n' |
*A* is not assumed to be unit triangular. |
Unchanged on exit. |

*M* |
On entry, *M *specifies the number of rows of *B*; *M* must
be at least 0; unchanged on exit. |

*N* |
On entry, *N* specifies the number of columns of *B*; *N*
must be at least 0; unchanged on exit. |

*ALPHA* |
On entry, *ALPHA* specifies the scalar alpha. When alpha is 0 then
*A* is not referenced and *B* need not be set before entry; unchanged on
exit. |

*A* |
An array of dimension ( *LDA*, k ), where k is *M* when
*SIDE* = 'L' or 'l' and is *N* when *SIDE* = 'R' or 'r'; on entry with
*UPLO* = 'U' or 'u', the leading k by k upper triangular part of the array*
A* must contain the upper triangular matrix and the strictly lower triangular part
of *A* is not referenced; on entry with *UPLO* = 'L' or 'l', the leading k
by k lower triangular part of the array *A* must contain the lower triangular
matrix and the strictly upper triangular part of* A* is not referenced. When
*DIAG* = 'U' or 'u', the diagonal elements of *A* are not referenced
either, but are assumed to be unity; unchanged on exit. |

*LDA* |
On entry, *LDA* specifies the first dimension of *A* as declared
in the calling (sub) program. When *SIDE* = 'L' or 'l' then *LDA* must be
at least max( 1, *M* ), when *SIDE* = 'R' or 'r' then *LDA* must be at
least max( 1, *N* ); unchanged on exit. |

*B* |
An array of dimension ( *LDB*, *N* ); on entry, the leading
*M* by *N* part of the array *B* must contain the matrix *B*, and
on exit is overwritten by the transformed matrix. |

*LDB* |
On entry, *LDB* specifies the first dimension of *B* as declared
in the calling (sub) program; *LDB* must be at least max( 1, *M* );
unchanged on exit. |

[ Previous |
Next |
Contents |
Glossary |
Home |
Search ]