sgems, dgems, cgems, zgems 

Matrix-matrix subtraction

FORMAT

  {S,D,C,Z}GEMS

  ( 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; m >= 0.
                      On exit, n is unchanged.

  alpha               Input 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 A 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, a two-dimensional array with the dimension
                      ldc by at least 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 _GEMS routines perform one of the following matrix-matrix 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.