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



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

SYNOPSIS
       SUBROUTINE SGEMM_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

           REAL         ALPHA, BETA

           REAL         A( STRIDEA, * ), B( STRIDEB, * ), C( STRIDEC, * )

PURPOSE
       SGEMM_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  - REAL            .
              On  entry, ALPHA specifies the scalar alpha.  Unchanged on exit.

       A      - REAL             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      - REAL             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   - REAL            .
              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      - REAL             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         SGEMM_BATCH_STRIDED(3)