DGEMM_BATCH_STRIDED(3)      BLAS routine of NEC NLC     DGEMM_BATCH_STRIDED(3)



NAME
       DGEMM_BATCH_STRIDED  -  Computes  groups  of matrix-matrix product with
       general matrices.

SYNOPSIS
       SUBROUTINE DGEMM_BATCH_STRIDED
                        ( TRANSA, TRANSB, M, N, K, ALPHA, A, STRIDEA, LDA,  B,
                        LDB, STRIDEB BETA, C, LDC, STRIDEC, BATCH_SIZE )

           CHARACTER*1  TRANSA, TRANSB

           INTEGER      M,  N,  K,  LDA,  STRIDEA, LDB, STRIDEB, LDC, STRIDEC,
                        BATCH_SIZE

           DOUBLE       PRECISION ALPHA, BETA

           DOUBLE       PRECISION A(  STRIDEA,  *  ),  B(  STRIDEB,  *  ),  C(
                        STRIDEC, * )

PURPOSE
       DGEMM_BATCH_STRIDED  computes  the matrix-matrix operations for a batch
       of general matrices. All matrices in the array A (respectively, B or C)
       have same parameters (size, leading dimension, transpose operation).
       The operation is defined as follows:
       For i = 0  batch_size - 1
           Ci = alpha*op( Ai )*op( Bi )+beta*Ci
       end for

       Where  Ai,  Bi,  and  Ci  are the i-th matrix in the array A, B, and C,
       respectively. stradea, strideb, and stridec  determine  the  offset  of
       each matrix. op( X ) is one of

          op( X ) = X   or   op( X ) = X',

       alpha and beta are scalars.

       This  routine  is not fully optimized. The performance will be improved
       in a future release.


PARAMETERS
       TRANSA - 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'.

              TRANSA = 'C' or 'c',  op( A ) = A'.

              Unchanged on exit.


       TRANSB - 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'.

              TRANSB = 'C' or 'c',  op( B ) = B'.

              Unchanged on exit.

       M      - 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.
              Unchanged on exit.

       N      - 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.  Unchanged on exit.

       K      - 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.  Unchanged on exit.

       ALPHA  - DOUBLE PRECISION.
              On entry, ALPHA specifies the scalar alpha.  Unchanged on  exit.

       A      - DOUBLE PRECISION array of DIMENSION ( STRIDEA, BATCH_SIZE ).
              Before  entry, STRIDEA*BATCH_SIZE part of the array  A must con-
              tain  the matrices A.  Unchanged on exit.

       LDA    - 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 ).  Unchanged on exit.

       STRIDEA    - INTEGER.
              On entry, STRIDEA specifies the stride between two consecutive A
              matrices.  Unchanged on exit.

       B      - DOUBLE PRECISION array of DIMENSION ( STRIDEB, BATCH_SIZE ).
              Before entry, STRIDEB*BATCH_SIZE part of the array  B must  con-
              tain  the matrices B.  Unchanged on exit.

       LDB    - 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 ).  Unchanged on exit.

       STRIDEB    - INTEGER.
              On entry, STRIDEB specifies the stride between two consecutive B
              matrices.  Unchanged on exit.

       BETA   - DOUBLE PRECISION.
              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      - DOUBLE PRECISION array of DIMENSION ( STRIDEC, BATCH_SIZE ).
              Before  entry, STRIDEC*BATCH_SIZE part of the array  C must con-
              tain  the matrices C, except when  beta  is zero, in which  case
              C need not be set on entry.  On exit, the array  C  is overwrit-
              ten by the  BATCH_SIZE  matrices (  alpha*op(  Ai  )*op(  Bi  )+
              beta*Ci ( i= 0 ... batch_size - 1 )).

       LDC    - 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 ).  Unchanged on exit.

       STRIDEC    - INTEGER.
              On entry, STRIDEC specifies the stride between two consecutive C
              matrices.  Unchanged on exit.

       BATCH_SIZE    - INTEGER.
              On entry, BATCH_SIZE specifies the number of  gemm  computations
              to  perform  and  a,  b  and  c  matrices.   Must be at least 0.
              Unchanged on exit.

              Level 3 Blas routine.




BLAS routine                    26 October 2021         DGEMM_BATCH_STRIDED(3)