Contents


NAME

     ztrmm - perform 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 one of   op(
     A ) = A or op( A ) = A' or op( A ) = conjg( A' )

SYNOPSIS

     SUBROUTINE ZTRMM(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B,
           LDB)

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

     SUBROUTINE ZTRMM_64(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B,
           LDB)

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

  F95 INTERFACE
     SUBROUTINE TRMM(SIDE, UPLO, [TRANSA], DIAG, [M], [N], ALPHA, A, [LDA],
            B, [LDB])

     CHARACTER(LEN=1) :: SIDE, UPLO, TRANSA, DIAG
     COMPLEX(8) :: ALPHA
     COMPLEX(8), DIMENSION(:,:) :: A, B
     INTEGER :: M, N, LDA, LDB

     SUBROUTINE TRMM_64(SIDE, UPLO, [TRANSA], DIAG, [M], [N], ALPHA, A,
            [LDA], B, [LDB])

     CHARACTER(LEN=1) :: SIDE, UPLO, TRANSA, DIAG
     COMPLEX(8) :: ALPHA
     COMPLEX(8), DIMENSION(:,:) :: A, B
     INTEGER(8) :: M, N, LDA, LDB

  C INTERFACE
     #include <sunperf.h>

     void ztrmm(char side, char uplo, char transa, char diag, int
               m,  int n, doublecomplex *alpha, doublecomplex *a,
               int lda, doublecomplex *b, int ldb);
     void ztrmm_64(char side, char uplo, char transa, char  diag,
               long  m,  long n, doublecomplex *alpha, doublecom-
               plex *a, long lda, doublecomplex *b, long ldb);

PURPOSE

     ztrmm 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 one of   op(
     A ) = A or op( A ) = A' or op( A ) = conjg( A' )

ARGUMENTS

     SIDE (input)
               On entry,  SIDE specifies whether  op( A )  multi-
               plies 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 (input)
               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 (input)
               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 ) = conjg( A' ).

               Unchanged on exit.

               TRANSA is defaulted to 'N' for F95 INTERFACE.
     DIAG (input)
               On entry, DIAG specifies whether or not A is  unit
               triangular as follows:

               DIAG = 'U' or 'u'   A is assumed to be  unit  tri-
               angular.

               DIAG = 'N' or 'n'   A is not assumed  to  be  unit
               triangular.

               Unchanged on exit.

     M (input)
               On entry, M specifies the number of rows of  B.  M
               >= 0.  Unchanged on exit.

     N (input)
               On entry, N specifies the number of columns of  B.
               N >= 0.  Unchanged on exit.

     ALPHA (input)
               On entry,  ALPHA specifies the scalar  alpha. When
               alpha  is  zero  then   A is not referenced and  B
               need not be set before entry.  Unchanged on exit.

     A (input)
               COMPLEX*16 array of DIMENSION ( LDA, k ), where  k
               is  m  when   SIDE  =  'L' or 'l'  and is  n  when
               SIDE = 'R' or 'r'.

               Before entry  with  UPLO = 'U' or 'u',  the  lead-
               ing   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 refer-
               enced.

               Before entry  with  UPLO = 'L' or 'l',  the  lead-
               ing   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 refer-
               enced.

               Note that when DIAG = 'U'  or  'u',  the  diagonal
               elements  of  A are not referenced either, but are
               assumed to be unity.

               Unchanged on exit.
     LDA (input)
               On entry, LDA specifies the first dimension  of  A
               as  declared  in  the calling (sub) program.  When
               SIDE = 'L' or 'l' then LDA >= max(1,M), when  SIDE
               =  'R'  or 'r' then LDA >= max(1,N).  Unchanged on
               exit.

     B (input/output)
               COMPLEX*16 array of DIMENSION ( LDB, n ).   Before
               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 (input)
               On entry, LDB specifies the first dimension  of  B
               as  declared  in the calling subprogram.  LDB must
               be at least max(1,M).  Unchanged on exit.