sgema, dgema, cgema, zgema 

Matrix-matrix addition

FORMAT

  {S,D,C,Z}GEMA

   ( transa, transb, m, n, alpha, a, lda, beta, b, ldb, c, ldc )

Arguments

  transa              character*1
                      On entry, specifies the form of (op)A as follows:

                      If transa = 'N' or

                      If transa = 'T' or

                      If transa = 'R' or

                      If transa = 'C' or
                      On exit, transa is unchanged.

  transb              character*1
                      On entry, specifies the form of (op)B as follows:

                      If transb = 'N' or

                      If transb = 'T' or

                      If transb = 'R' or

                      If transb = 'C' or
                      On exit, transb is unchanged.

  m                   integer*4
                      On entry, the number of rows in the matrices (op)A,
                      (op)B, and C; m >= 0.
                      On exit, m is unchanged.

  n                   integer*4
                      On entry, the number of columns in the matrices (op)A,
                      (op)B, and C; n >= 0.
                      On exit, n is unchanged.

  alpha               real*4 | real*8 | complex*8 | complex*16
                      On entry, specifies the scalar alpha.
                      On exit, alpha is unchanged.

  a                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a two-dimensional array A with dimensions lda
                      by k.
                      For (op)A = A  or  conjugate(A), k = n  and the leading
                      m by n part of array A contains the matrix A.
                      For (op)A = transp(A)  or  conjug_transp(A), k = m and
                      the leading n by m part of array A contains the matrix
                      A.
                      On exit, a is unchanged.

  lda                 integer*4
                      On entry, specifies the first dimension of array A.
                      For (op)A = A  or  conjugate(A), lda >= MAX(1, m).
                      For (op)A = transp(A)  or  conjug_transp(A), lda >=
                      MAX(1, n).
                      On exit, lda is unchanged.

  beta                real*4 | real*8 | complex*8 | complex*16
                      On entry, specifies the scalar beta.
                      On exit, beta is unchanged.

  b                   real*4 | real*8 | complex*8 | complex*16
                      On entry, a two-dimensional array  with dimensions ldb
                      by k.
                      For (op)B = B  or  conjugate(B), k = n  and the leading
                      m by n part of array B contains the matrix B.
                      For (op)B = transp(B)  or  conjug_transp(B), k = m and
                      the leading n by m part of array B contains the matrix
                      B.

  ldb                 integer*4
                      On entry, specifies the first dimension of array B.
                      For (op)B = B  or  conjugate(B), ldb >= MAX(1, m).
                      For (op)B = transp(B)  or  conjug_transp(B), ldb >=
                      MAX(1, n).
                      On exit, ldb is unchanged.

  c                   real*4 | real*8 | complex*8 | complex*16
                      On entry, an array with the dimension ldc by n.
                      On exit,  the leading  m by n part of array C is
                      overwritten by the matrix alpha*(op)A + beta*(op)B.

  ldc                 integer*4
                      On entry, specifies the first dimension of array C; ldc
                      >= MAX( 1, m ).
                      On exit, ldc is unchanged.

Description

  The _GEMA  routines perform the following operations:
       C  =  alpha * op(A) + beta * op(B) where (op)(X) = X, transp(X),
  conjugate(X),
   or  conjug_transp(X) , alpha and beta are scalars, and A, B, and C are
  matrices. (op)A, (op)B, and C are m by n matrices.

  These subroutines can also perform the following operation when lda = ldc,
  and transa = when (op)A = A A  = alpha * A + beta *  (op)B where (op)(X) =
  X, transp(X), conjugate(X),
   or  conjug_transp(X) , alpha and beta are scalars, and A and B are m by n
  matrices.