gemm(3)

NAME
gemm - gemm: general matrix-matrix multiply

SYNOPSIS

  Functions
subroutine cgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
CGEMM
subroutine dgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
DGEMM
subroutine sgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
SGEMM
subroutine zgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
ZGEMM

Detailed Description

Function Documentation

  subroutine cgemm (character transa, character transb, integer m, integer n, integer k, complex alpha, complex, dimension(lda,*) a, integer lda, complex, dimension(ldb,*) b, integer ldb, complex beta, complex, dimension(ldc,*) c, integer ldc)

CGEMM

Purpose:

    !>
    !> CGEMM  performs one of the matrix-matrix operations
    !>
    !>    C := alpha*op( A )*op( B ) + beta*C,
    !>
    !> where  op( X ) is one of
    !>
    !>    op( X ) = X   or   op( X ) = X**T   or   op( X ) = X**H,
    !>
    !> alpha and beta are scalars, and A, B and C are matrices, with op( A )
    !> an m by k matrix,  op( B )  a  k by n matrix and  C an m by n matrix.
    !>

Parameters
    TRANSA

    !>          TRANSA is CHARACTER*1
    !>           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**T.
    !>
    !>              TRANSA = 'C' or 'c',  op( A ) = A**H.
    !>

    TRANSB

    !>          TRANSB is CHARACTER*1
    !>           On entry, TRANSB specifies the form of op( B ) to be used in
    !>           the matrix multiplication as follows:
    !>
    !>              TRANSB = 'N' or 'n',  op( B ) = B.
    !>
    !>              TRANSB = 'T' or 't',  op( B ) = B**T.
    !>
    !>              TRANSB = 'C' or 'c',  op( B ) = B**H.
    !>

    M

    !>          M is INTEGER
    !>           On entry,  M  specifies  the number  of rows  of the  matrix
    !>           op( A )  and of the  matrix  C.  M  must  be at least  zero.
    !>

    N

    !>          N is INTEGER
    !>           On entry,  N  specifies the number  of columns of the matrix
    !>           op( B ) and the number of columns of the matrix C. N must be
    !>           at least zero.
    !>

    K

    !>          K is INTEGER
    !>           On entry,  K  specifies  the number of columns of the matrix
    !>           op( A ) and the number of rows of the matrix op( B ). K must
    !>           be at least  zero.
    !>

    ALPHA

    !>          ALPHA is COMPLEX
    !>           On entry, ALPHA specifies the scalar alpha.
    !>

    A

    !>          A is COMPLEX array, dimension ( LDA, ka ), where ka is
    !>           k  when  TRANSA = 'N' or 'n',  and is  m  otherwise.
    !>           Before entry with  TRANSA = 'N' or 'n',  the leading  m by k
    !>           part of the array  A  must contain the matrix  A,  otherwise
    !>           the leading  k by m  part of the array  A  must contain  the
    !>           matrix A.
    !>

    LDA

    !>          LDA is INTEGER
    !>           On entry, LDA specifies the first dimension of A as declared
    !>           in the calling (sub) program. When  TRANSA = 'N' or 'n' then
    !>           LDA must be at least  max( 1, m ), otherwise  LDA must be at
    !>           least  max( 1, k ).
    !>

    B

    !>          B is COMPLEX array, dimension ( LDB, kb ), where kb is
    !>           n  when  TRANSB = 'N' or 'n',  and is  k  otherwise.
    !>           Before entry with  TRANSB = 'N' or 'n',  the leading  k by n
    !>           part of the array  B  must contain the matrix  B,  otherwise
    !>           the leading  n by k  part of the array  B  must contain  the
    !>           matrix B.
    !>

    LDB

    !>          LDB is INTEGER
    !>           On entry, LDB specifies the first dimension of B as declared
    !>           in the calling (sub) program. When  TRANSB = 'N' or 'n' then
    !>           LDB must be at least  max( 1, k ), otherwise  LDB must be at
    !>           least  max( 1, n ).
    !>

    BETA

    !>          BETA is COMPLEX
    !>           On entry,  BETA  specifies the scalar  beta.  When  BETA  is
    !>           supplied as zero then C need not be set on input.
    !>

    C

    !>          C is COMPLEX array, 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  matrix
    !>           ( alpha*op( A )*op( B ) + beta*C ).
    !>

    LDC

    !>          LDC is INTEGER
    !>           On entry, LDC specifies the first dimension of C as declared
    !>           in  the  calling  (sub)  program.   LDC  must  be  at  least
    !>           max( 1, m ).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  Level 3 Blas routine.
    !>
    !>  -- Written on 8-February-1989.
    !>     Jack Dongarra, Argonne National Laboratory.
    !>     Iain Duff, AERE Harwell.
    !>     Jeremy Du Croz, Numerical Algorithms Group Ltd.
    !>     Sven Hammarling, Numerical Algorithms Group Ltd.
    !>

Definition at line 186 of file cgemm.f.

  subroutine dgemm (character transa, character transb, integer m, integer n, integer k, double precision alpha, double precision, dimension(lda,*) a, integer lda, double precision, dimension(ldb,*) b, integer ldb, double precision beta, double precision, dimension(ldc,*) c, integer ldc)

DGEMM

Purpose:

    !>
    !> DGEMM  performs one of the matrix-matrix operations
    !>
    !>    C := alpha*op( A )*op( B ) + beta*C,
    !>
    !> where  op( X ) is one of
    !>
    !>    op( X ) = X   or   op( X ) = X**T,
    !>
    !> alpha and beta are scalars, and A, B and C are matrices, with op( A )
    !> an m by k matrix,  op( B )  a  k by n matrix and  C an m by n matrix.
    !>

Parameters
    TRANSA

    !>          TRANSA is CHARACTER*1
    !>           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**T.
    !>
    !>              TRANSA = 'C' or 'c',  op( A ) = A**T.
    !>

    TRANSB

    !>          TRANSB is CHARACTER*1
    !>           On entry, TRANSB specifies the form of op( B ) to be used in
    !>           the matrix multiplication as follows:
    !>
    !>              TRANSB = 'N' or 'n',  op( B ) = B.
    !>
    !>              TRANSB = 'T' or 't',  op( B ) = B**T.
    !>
    !>              TRANSB = 'C' or 'c',  op( B ) = B**T.
    !>

    M

    !>          M is INTEGER
    !>           On entry,  M  specifies  the number  of rows  of the  matrix
    !>           op( A )  and of the  matrix  C.  M  must  be at least  zero.
    !>

    N

    !>          N is INTEGER
    !>           On entry,  N  specifies the number  of columns of the matrix
    !>           op( B ) and the number of columns of the matrix C. N must be
    !>           at least zero.
    !>

    K

    !>          K is INTEGER
    !>           On entry,  K  specifies  the number of columns of the matrix
    !>           op( A ) and the number of rows of the matrix op( B ). K must
    !>           be at least  zero.
    !>

    ALPHA

    !>          ALPHA is DOUBLE PRECISION.
    !>           On entry, ALPHA specifies the scalar alpha.
    !>

    A

    !>          A is DOUBLE PRECISION array, dimension ( LDA, ka ), where ka is
    !>           k  when  TRANSA = 'N' or 'n',  and is  m  otherwise.
    !>           Before entry with  TRANSA = 'N' or 'n',  the leading  m by k
    !>           part of the array  A  must contain the matrix  A,  otherwise
    !>           the leading  k by m  part of the array  A  must contain  the
    !>           matrix A.
    !>

    LDA

    !>          LDA is INTEGER
    !>           On entry, LDA specifies the first dimension of A as declared
    !>           in the calling (sub) program. When  TRANSA = 'N' or 'n' then
    !>           LDA must be at least  max( 1, m ), otherwise  LDA must be at
    !>           least  max( 1, k ).
    !>

    B

    !>          B is DOUBLE PRECISION array, dimension ( LDB, kb ), where kb is
    !>           n  when  TRANSB = 'N' or 'n',  and is  k  otherwise.
    !>           Before entry with  TRANSB = 'N' or 'n',  the leading  k by n
    !>           part of the array  B  must contain the matrix  B,  otherwise
    !>           the leading  n by k  part of the array  B  must contain  the
    !>           matrix B.
    !>

    LDB

    !>          LDB is INTEGER
    !>           On entry, LDB specifies the first dimension of B as declared
    !>           in the calling (sub) program. When  TRANSB = 'N' or 'n' then
    !>           LDB must be at least  max( 1, k ), otherwise  LDB must be at
    !>           least  max( 1, n ).
    !>

    BETA

    !>          BETA is DOUBLE PRECISION.
    !>           On entry,  BETA  specifies the scalar  beta.  When  BETA  is
    !>           supplied as zero then C need not be set on input.
    !>

    C

    !>          C is DOUBLE PRECISION array, 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  matrix
    !>           ( alpha*op( A )*op( B ) + beta*C ).
    !>

    LDC

    !>          LDC is INTEGER
    !>           On entry, LDC specifies the first dimension of C as declared
    !>           in  the  calling  (sub)  program.   LDC  must  be  at  least
    !>           max( 1, m ).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  Level 3 Blas routine.
    !>
    !>  -- Written on 8-February-1989.
    !>     Jack Dongarra, Argonne National Laboratory.
    !>     Iain Duff, AERE Harwell.
    !>     Jeremy Du Croz, Numerical Algorithms Group Ltd.
    !>     Sven Hammarling, Numerical Algorithms Group Ltd.
    !>

Definition at line 186 of file dgemm.f.

  subroutine sgemm (character transa, character transb, integer m, integer n, integer k, real alpha, real, dimension(lda,*) a, integer lda, real, dimension(ldb,*) b, integer ldb, real beta, real, dimension(ldc,*) c, integer ldc)

SGEMM

Purpose:

    !>
    !> SGEMM  performs one of the matrix-matrix operations
    !>
    !>    C := alpha*op( A )*op( B ) + beta*C,
    !>
    !> where  op( X ) is one of
    !>
    !>    op( X ) = X   or   op( X ) = X**T,
    !>
    !> alpha and beta are scalars, and A, B and C are matrices, with op( A )
    !> an m by k matrix,  op( B )  a  k by n matrix and  C an m by n matrix.
    !>

Parameters
    TRANSA

    !>          TRANSA is CHARACTER*1
    !>           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**T.
    !>
    !>              TRANSA = 'C' or 'c',  op( A ) = A**T.
    !>

    TRANSB

    !>          TRANSB is CHARACTER*1
    !>           On entry, TRANSB specifies the form of op( B ) to be used in
    !>           the matrix multiplication as follows:
    !>
    !>              TRANSB = 'N' or 'n',  op( B ) = B.
    !>
    !>              TRANSB = 'T' or 't',  op( B ) = B**T.
    !>
    !>              TRANSB = 'C' or 'c',  op( B ) = B**T.
    !>

    M

    !>          M is INTEGER
    !>           On entry,  M  specifies  the number  of rows  of the  matrix
    !>           op( A )  and of the  matrix  C.  M  must  be at least  zero.
    !>

    N

    !>          N is INTEGER
    !>           On entry,  N  specifies the number  of columns of the matrix
    !>           op( B ) and the number of columns of the matrix C. N must be
    !>           at least zero.
    !>

    K

    !>          K is INTEGER
    !>           On entry,  K  specifies  the number of columns of the matrix
    !>           op( A ) and the number of rows of the matrix op( B ). K must
    !>           be at least  zero.
    !>

    ALPHA

    !>          ALPHA is REAL
    !>           On entry, ALPHA specifies the scalar alpha.
    !>

    A

    !>          A is REAL array, dimension ( LDA, ka ), where ka is
    !>           k  when  TRANSA = 'N' or 'n',  and is  m  otherwise.
    !>           Before entry with  TRANSA = 'N' or 'n',  the leading  m by k
    !>           part of the array  A  must contain the matrix  A,  otherwise
    !>           the leading  k by m  part of the array  A  must contain  the
    !>           matrix A.
    !>

    LDA

    !>          LDA is INTEGER
    !>           On entry, LDA specifies the first dimension of A as declared
    !>           in the calling (sub) program. When  TRANSA = 'N' or 'n' then
    !>           LDA must be at least  max( 1, m ), otherwise  LDA must be at
    !>           least  max( 1, k ).
    !>

    B

    !>          B is REAL array, dimension ( LDB, kb ), where kb is
    !>           n  when  TRANSB = 'N' or 'n',  and is  k  otherwise.
    !>           Before entry with  TRANSB = 'N' or 'n',  the leading  k by n
    !>           part of the array  B  must contain the matrix  B,  otherwise
    !>           the leading  n by k  part of the array  B  must contain  the
    !>           matrix B.
    !>

    LDB

    !>          LDB is INTEGER
    !>           On entry, LDB specifies the first dimension of B as declared
    !>           in the calling (sub) program. When  TRANSB = 'N' or 'n' then
    !>           LDB must be at least  max( 1, k ), otherwise  LDB must be at
    !>           least  max( 1, n ).
    !>

    BETA

    !>          BETA is REAL
    !>           On entry,  BETA  specifies the scalar  beta.  When  BETA  is
    !>           supplied as zero then C need not be set on input.
    !>

    C

    !>          C is REAL array, 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  matrix
    !>           ( alpha*op( A )*op( B ) + beta*C ).
    !>

    LDC

    !>          LDC is INTEGER
    !>           On entry, LDC specifies the first dimension of C as declared
    !>           in  the  calling  (sub)  program.   LDC  must  be  at  least
    !>           max( 1, m ).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  Level 3 Blas routine.
    !>
    !>  -- Written on 8-February-1989.
    !>     Jack Dongarra, Argonne National Laboratory.
    !>     Iain Duff, AERE Harwell.
    !>     Jeremy Du Croz, Numerical Algorithms Group Ltd.
    !>     Sven Hammarling, Numerical Algorithms Group Ltd.
    !>

Definition at line 186 of file sgemm.f.

  subroutine zgemm (character transa, character transb, integer m, integer n, integer k, complex*16 alpha, complex*16, dimension(lda,*) a, integer lda, complex*16, dimension(ldb,*) b, integer ldb, complex*16 beta, complex*16, dimension(ldc,*) c, integer ldc)

ZGEMM

Purpose:

    !>
    !> ZGEMM  performs one of the matrix-matrix operations
    !>
    !>    C := alpha*op( A )*op( B ) + beta*C,
    !>
    !> where  op( X ) is one of
    !>
    !>    op( X ) = X   or   op( X ) = X**T   or   op( X ) = X**H,
    !>
    !> alpha and beta are scalars, and A, B and C are matrices, with op( A )
    !> an m by k matrix,  op( B )  a  k by n matrix and  C an m by n matrix.
    !>

Parameters
    TRANSA

    !>          TRANSA is CHARACTER*1
    !>           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**T.
    !>
    !>              TRANSA = 'C' or 'c',  op( A ) = A**H.
    !>

    TRANSB

    !>          TRANSB is CHARACTER*1
    !>           On entry, TRANSB specifies the form of op( B ) to be used in
    !>           the matrix multiplication as follows:
    !>
    !>              TRANSB = 'N' or 'n',  op( B ) = B.
    !>
    !>              TRANSB = 'T' or 't',  op( B ) = B**T.
    !>
    !>              TRANSB = 'C' or 'c',  op( B ) = B**H.
    !>

    M

    !>          M is INTEGER
    !>           On entry,  M  specifies  the number  of rows  of the  matrix
    !>           op( A )  and of the  matrix  C.  M  must  be at least  zero.
    !>

    N

    !>          N is INTEGER
    !>           On entry,  N  specifies the number  of columns of the matrix
    !>           op( B ) and the number of columns of the matrix C. N must be
    !>           at least zero.
    !>

    K

    !>          K is INTEGER
    !>           On entry,  K  specifies  the number of columns of the matrix
    !>           op( A ) and the number of rows of the matrix op( B ). K must
    !>           be at least  zero.
    !>

    ALPHA

    !>          ALPHA is COMPLEX*16
    !>           On entry, ALPHA specifies the scalar alpha.
    !>

    A

    !>          A is COMPLEX*16 array, dimension ( LDA, ka ), where ka is
    !>           k  when  TRANSA = 'N' or 'n',  and is  m  otherwise.
    !>           Before entry with  TRANSA = 'N' or 'n',  the leading  m by k
    !>           part of the array  A  must contain the matrix  A,  otherwise
    !>           the leading  k by m  part of the array  A  must contain  the
    !>           matrix A.
    !>

    LDA

    !>          LDA is INTEGER
    !>           On entry, LDA specifies the first dimension of A as declared
    !>           in the calling (sub) program. When  TRANSA = 'N' or 'n' then
    !>           LDA must be at least  max( 1, m ), otherwise  LDA must be at
    !>           least  max( 1, k ).
    !>

    B

    !>          B is COMPLEX*16 array, dimension ( LDB, kb ), where kb is
    !>           n  when  TRANSB = 'N' or 'n',  and is  k  otherwise.
    !>           Before entry with  TRANSB = 'N' or 'n',  the leading  k by n
    !>           part of the array  B  must contain the matrix  B,  otherwise
    !>           the leading  n by k  part of the array  B  must contain  the
    !>           matrix B.
    !>

    LDB

    !>          LDB is INTEGER
    !>           On entry, LDB specifies the first dimension of B as declared
    !>           in the calling (sub) program. When  TRANSB = 'N' or 'n' then
    !>           LDB must be at least  max( 1, k ), otherwise  LDB must be at
    !>           least  max( 1, n ).
    !>

    BETA

    !>          BETA is COMPLEX*16
    !>           On entry,  BETA  specifies the scalar  beta.  When  BETA  is
    !>           supplied as zero then C need not be set on input.
    !>

    C

    !>          C is COMPLEX*16 array, 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  matrix
    !>           ( alpha*op( A )*op( B ) + beta*C ).
    !>

    LDC

    !>          LDC is INTEGER
    !>           On entry, LDC specifies the first dimension of C as declared
    !>           in  the  calling  (sub)  program.   LDC  must  be  at  least
    !>           max( 1, m ).
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  Level 3 Blas routine.
    !>
    !>  -- Written on 8-February-1989.
    !>     Jack Dongarra, Argonne National Laboratory.
    !>     Iain Duff, AERE Harwell.
    !>     Jeremy Du Croz, Numerical Algorithms Group Ltd.
    !>     Sven Hammarling, Numerical Algorithms Group Ltd.
    !>

Definition at line 186 of file zgemm.f.

Author

Generated automatically by Doxygen for LAPACK from the source code.