Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.netlib.blas
Class SGEMM

    java.lang.Object
      org.netlib.blas.SGEMM

    public class SGEMM

extends java.lang.Object

    SGEMM is a simplified interface to the JLAPACK routine sgemm.
    This interface converts Java-style 2D row-major arrays into
    the 1D column-major linearized arrays expected by the lower
    level JLAPACK routines.  Using this interface also allows you
    to omit offset and leading dimension arguments.  However, because
    of these conversions, these routines will be slower than the low
    level ones.  Following is the description from the original Fortran
    source.  Contact seymour@cs.utk.edu with any questions.

     *     ..
     *
     *  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',
     *
     *  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.
     *
     *  Arguments
     *  ==========
     *
     *  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 ( 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.
     *           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.
     *
     *  B      - REAL             array of 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.
     *           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.
     *
     *  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 ( 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    - 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.
     *
     *
     *  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.
     *
     *
     *     .. External Functions ..

Constructor Summary
`SGEMM()`

Method Summary
`static void` | `SGEMM(java.lang.String transa, java.lang.String transb, int m, int n, int k, float alpha, float[][] a, float[][] b, float beta, float[][] c)`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### SGEMM

    public SGEMM()

Method Detail

### SGEMM

    public static void SGEMM(java.lang.String transa,
                             java.lang.String transb,
                             int m,
                             int n,
                             int k,
                             float alpha,
                             float[][] a,
                             float[][] b,
                             float beta,
                             float[][] c)

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD