drasys.or.linear.blas
Interface BLAS3I

All Known Implementing Classes:

SmpBLAS3, BLAS3

public interface BLAS3I

Defines an array based BLAS3 for Java. Blas3 operates on matrices stored contiguously in one-dimensional arrays. It also supports sub-matrices which allow it to work with both '0' and '1' based indexing. The increment arguments 'inci' and 'incj' allow this method to operate directly on both row-major and column-major structures.
The arrays containing complex elements store each complex element in two adjacent array positions. The real component has the even index and the imaginary component has the next higher index. The 'beg*' and 'inc*' arguments specify the logical index of the complex element, these are multiplied by two internally to obtain the offset into the array.

See Also:

RowMajorMatrix, ColumnMajorMatrix, RowMajorMatrix,

References:

Linear Algebra and Its Applications
    Gilbert Strang / Hardcover / Published 1988
Matrix Computations (Johns Hopkins Studies in the Mathematical Sciences)
    Gene H. Golub, Charles F. Van Loan (Contributor) / Paperback / Published 1996
Numerical Recipes in C : The Art of Scientific Computing
    William H. Press, et al / Hardcover / Published 1993


Method Summary
void	cgemm(int m, int n, int k, ComplexI alpha, float[] A, int begA, int incAi, int incAj, float[] B, int begB, int incBi, int incBj, ComplexI beta, float[] C, int begC, int incCi, int incCj)           Computes: C = alpha*A*B + beta*C.
void	dgemm(int m, int n, int k, double alpha, double[] A, int begA, int incAi, int incAj, double[] B, int begB, int incBi, int incBj, double beta, double[] C, int begC, int incCi, int incCj)           Computes: C = alpha*A*B + beta*C.
void	sgemm(int m, int n, int k, float alpha, float[] A, int begA, int incAi, int incAj, float[] B, int begB, int incBi, int incBj, float beta, float[] C, int begC, int incCi, int incCj)           Computes: C = alpha*A*B + beta*C.
void	zgemm(int m, int n, int k, ComplexI alpha, double[] A, int begA, int incAi, int incAj, double[] B, int begB, int incBi, int incBj, ComplexI beta, double[] C, int begC, int incCi, int incCj)           Computes: C = alpha*A*B + beta*C.

 

Method Detail

dgemm

public void dgemm(int m,
                  int n,
                  int k,
                  double alpha,
                  double[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  double[] B,
                  int begB,
                  int incBi,
                  int incBj,
                  double beta,
                  double[] C,
                  int begC,
                  int incCi,
                  int incCj)
           throws BlasException

Computes: C = alpha*A*B + beta*C. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'. The transpose of 'B' can be used by swapping 'incBi' and 'incBj'.

Parameters:

m - number of rows in 'A' and 'C'

n - number of columns in 'B' and 'C'

k - number of columns in 'A' and rows in 'B'

alpha - constant scaler

A - the matrix 'A' in contiguous format

begA - offset of the first element of 'A'

incAi - row increment for matrix 'A'

incAj - column increment for matrix 'A'

B - the matrix 'B' in contiguous format

begB - offset of the first element of 'B'

incBi - row increment for matrix 'B'

incBj - column increment for matrix 'B'

beta - constant scaler

C - the matrix 'C' in contiguous format

begC - offset of the first element of 'B'

incCi - row increment for matrix 'B'

incCj - column increment for matrix 'B'

sgemm

public void sgemm(int m,
                  int n,
                  int k,
                  float alpha,
                  float[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  float[] B,
                  int begB,
                  int incBi,
                  int incBj,
                  float beta,
                  float[] C,
                  int begC,
                  int incCi,
                  int incCj)
           throws BlasException

Computes: C = alpha*A*B + beta*C. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'. The transpose of 'B' can be used by swapping 'incBi' and 'incBj'.

Parameters:

m - number of rows in 'A' and 'C'

n - number of columns in 'B' and 'C'

k - number of columns in 'A' and rows in 'B'

alpha - constant scaler

A - the matrix 'A' in contiguous format

begA - offset of the first element of 'A'

incAi - row increment for matrix 'A'

incAj - column increment for matrix 'A'

B - the matrix 'B' in contiguous format

begB - offset of the first element of 'B'

incBi - row increment for matrix 'B'

incBj - column increment for matrix 'B'

beta - constant scaler

C - the matrix 'C' in contiguous format

begC - offset of the first element of 'B'

incCi - row increment for matrix 'B'

incCj - column increment for matrix 'B'

zgemm

public void zgemm(int m,
                  int n,
                  int k,
                  ComplexI alpha,
                  double[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  double[] B,
                  int begB,
                  int incBi,
                  int incBj,
                  ComplexI beta,
                  double[] C,
                  int begC,
                  int incCi,
                  int incCj)
           throws BlasException

Computes: C = alpha*A*B + beta*C. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'. The transpose of 'B' can be used by swapping 'incBi' and 'incBj'.

Parameters:

m - number of rows in 'A' and 'C'

n - number of columns in 'B' and 'C'

k - number of columns in 'A' and rows in 'B'

alpha - constant scaler

A - the matrix 'A' in contiguous format

begA - offset of the first element of 'A'

incAi - row increment for matrix 'A'

incAj - column increment for matrix 'A'

B - the matrix 'B' in contiguous format

begB - offset of the first element of 'B'

incBi - row increment for matrix 'B'

incBj - column increment for matrix 'B'

beta - constant scaler

C - the matrix 'C' in contiguous format

begC - offset of the first element of 'B'

incCi - row increment for matrix 'B'

incCj - column increment for matrix 'B'

cgemm

public void cgemm(int m,
                  int n,
                  int k,
                  ComplexI alpha,
                  float[] A,
                  int begA,
                  int incAi,
                  int incAj,
                  float[] B,
                  int begB,
                  int incBi,
                  int incBj,
                  ComplexI beta,
                  float[] C,
                  int begC,
                  int incCi,
                  int incCj)
           throws BlasException

Computes: C = alpha*A*B + beta*C. The transpose of 'A' can be used by swapping 'incAi' and 'incAj'. The transpose of 'B' can be used by swapping 'incBi' and 'incBj'.

Parameters:

m - number of rows in 'A' and 'C'

n - number of columns in 'B' and 'C'

k - number of columns in 'A' and rows in 'B'

alpha - constant scaler

A - the matrix 'A' in contiguous format

begA - offset of the first element of 'A'

incAi - row increment for matrix 'A'

incAj - column increment for matrix 'A'

B - the matrix 'B' in contiguous format

begB - offset of the first element of 'B'

incBi - row increment for matrix 'B'

incBj - column increment for matrix 'B'

beta - constant scaler

C - the matrix 'C' in contiguous format

begC - offset of the first element of 'B'

incCi - row increment for matrix 'B'

incCj - column increment for matrix 'B'