Contents


NAME

     dsymm - perform one of the matrix-matrix operations    C  :=
     alpha*A*B + beta*C or C := alpha*B*A + beta*C

SYNOPSIS

     SUBROUTINE DSYMM(SIDE, UPLO, M, N, ALPHA, A, LDA, B, LDB, BETA, C,
           LDC)

     CHARACTER * 1 SIDE, UPLO
     INTEGER M, N, LDA, LDB, LDC
     DOUBLE PRECISION ALPHA, BETA
     DOUBLE PRECISION A(LDA,*), B(LDB,*), C(LDC,*)

     SUBROUTINE DSYMM_64(SIDE, UPLO, M, N, ALPHA, A, LDA, B, LDB, BETA, C,
           LDC)

     CHARACTER * 1 SIDE, UPLO
     INTEGER*8 M, N, LDA, LDB, LDC
     DOUBLE PRECISION ALPHA, BETA
     DOUBLE PRECISION A(LDA,*), B(LDB,*), C(LDC,*)

  F95 INTERFACE
     SUBROUTINE SYMM(SIDE, UPLO, [M], [N], ALPHA, A, [LDA], B, [LDB],
            BETA, C, [LDC])

     CHARACTER(LEN=1) :: SIDE, UPLO
     INTEGER :: M, N, LDA, LDB, LDC
     REAL(8) :: ALPHA, BETA
     REAL(8), DIMENSION(:,:) :: A, B, C

     SUBROUTINE SYMM_64(SIDE, UPLO, [M], [N], ALPHA, A, [LDA], B, [LDB],
            BETA, C, [LDC])

     CHARACTER(LEN=1) :: SIDE, UPLO
     INTEGER(8) :: M, N, LDA, LDB, LDC
     REAL(8) :: ALPHA, BETA
     REAL(8), DIMENSION(:,:) :: A, B, C

  C INTERFACE
     #include <sunperf.h>

     void dsymm(char side, char uplo, int m, int n, double alpha,
               double  *a,  int  lda,  double *b, int ldb, double
               beta, double *c, int ldc);

     void dsymm_64(char side, char uplo, long m, long  n,  double
               alpha,  double  *a, long lda, double *b, long ldb,
               double beta, double *c, long ldc);

PURPOSE

     dsymm performs one of  the  matrix-matrix  operations  C  :=
     alpha*A*B  +  beta*C  or C := alpha*B*A + beta*C where alpha
     and beta are scalars,  A is a symmetric matrix and  B and  C
     are  m by n matrices.

ARGUMENTS

     SIDE (input)
               On entry,  SIDE  specifies whether  the  symmetric
               matrix   A  appears  on the  left or right  in the
               operation as follows:

               SIDE = 'L' or 'l'   C := alpha*A*B + beta*C,

               SIDE = 'R' or 'r'   C := alpha*B*A + beta*C,

               Unchanged on exit.

     UPLO (input)
               On  entry,   UPLO  specifies  whether  the   upper
               or   lower  triangular   part   of  the  symmetric
               matrix   A  is  to  be referenced as follows:

               UPLO = 'U' or 'u'   Only the upper triangular part
               of the symmetric matrix is to be referenced.

               UPLO = 'L' or 'l'   Only the lower triangular part
               of the symmetric matrix is to be referenced.

               Unchanged on exit.

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

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

     ALPHA (input)
               On  entry,  ALPHA  specifies  the  scalar   alpha.
               Unchanged on exit.
     A (input)
               DOUBLE PRECISION array of DIMENSION ( LDA,  ka  ),
               where  ka is m  when  SIDE = 'L' or 'l'  and is  n
               otherwise.

               Before entry  with  SIDE = 'L' or 'l',  the  m  by
               m   part  of  the array  A  must contain the  sym-
               metric matrix,  such that when  UPLO = 'U' or 'u',
               the  leading  m  by m upper triangular part of the
               array  A  must contain the upper  triangular  part
               of  the  symmetric matrix and the  strictly  lower
               triangular part of  A   is  not  referenced,   and
               when   UPLO  =  'L'  or  'l',  the leading  m by m
               lower triangular part  of the  array  A must  con-
               tain   the   lower  triangular  part  of the  sym-
               metric matrix and the  strictly  upper  triangular
               part of  A  is not referenced.

               Before entry  with  SIDE = 'R' or 'r',  the  n  by
               n   part  of  the array  A  must contain the  sym-
               metric matrix,  such that when  UPLO = 'U' or 'u',
               the  leading  n  by n upper triangular part of the
               array  A  must contain the upper  triangular  part
               of  the  symmetric matrix and the  strictly  lower
               triangular part of  A   is  not  referenced,   and
               when   UPLO  =  'L'  or  'l',  the leading  n by n
               lower triangular part  of the  array  A must  con-
               tain   the   lower  triangular  part  of the  sym-
               metric matrix and the  strictly  upper  triangular
               part of  A  is not referenced.

               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 ), other-
               wise  LDA >= max( 1, n ).  Unchanged on exit.

     B (input)
               DOUBLE PRECISION array of DIMENSION (  LDB,  n  ).
               Before  entry,  the  leading   m  by n part of the
               array  B  must contain the matrix B.  Unchanged on
               exit.

     LDB (input)
               On entry, LDB specifies the first dimension  of  B
               as  declared  in   the   calling   (sub)  program.
               LDB >= max( 1, m ).  Unchanged on exit.
     BETA (input)
               On entry,  BETA  specifies the scalar  beta.  When
               BETA   is  supplied as zero then C need not be set
               on input.  Unchanged on exit.

     C (input/output)
               DOUBLE PRECISION array of DIMENSION (  LDC,  n  ).
               Before  entry,  the  leading   m by n  part of the
               array  C must contain the matrix  C,  except  when
               beta   is zero, in which case C need not be set on
               entry.  On exit, the array  C  is  overwritten  by
               the  m by n updated matrix.

     LDC (input)
               On entry, LDC specifies the first dimension  of  C
               as  declared  in   the   calling   (sub)  program.
               LDC >= max( 1, m ).  Unchanged on exit.