public class BlasExt extends Object
Intel MKL (Math Kernel Library) native implementations of selected
BLAS extensions.
Matrix storage layout must be column-major as in Fortran. The number of
matrix rows and columns must always be strictly positive. All operations
throw a NullPointerException if any of the reference method arguments
is null.
| Modifier | Constructor and Description |
|---|---|
protected |
BlasExt() |
| Modifier and Type | Method and Description |
|---|---|
void |
cgemm3m(Trans transa,
Trans transb,
int m,
int n,
int k,
float alphar,
float alphai,
float[] a,
int lda,
float[] b,
int ldb,
float betar,
float betai,
float[] c,
int ldc) |
void |
cimatcopy(TTrans trans,
int rows,
int cols,
float alphar,
float alphai,
float[] AB,
int lda,
int ldb)
Scaling and in-place transposition / copying of a single precision
complex matrix
AB := alpha *op( AB ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation. |
void |
comatadd(TTrans transa,
TTrans transb,
int m,
int n,
float alphar,
float alphai,
float[] A,
int lda,
float betar,
float betai,
float[] B,
int ldb,
float[] C,
int ldc)
Scales and adds two single precision complex matrices, as well as
performing out-of-place transposition operations
C := alpha *op(A) + beta *op(B) where the op() operations
are transpose, conjugate-transpose, conjugate (no transpose), or no
transpose, depending on the values of transa and transb. |
void |
comatcopy(TTrans trans,
int rows,
int cols,
float alphar,
float alphai,
float[] A,
int lda,
float[] B,
int ldb)
Scaling and out-of-place transposition / copying of a single precision
complex matrix
B := alpha *op( A ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation. |
void |
dimatcopy(TTrans trans,
int rows,
int cols,
double alpha,
double[] AB,
int lda,
int ldb)
Scaling and in-place transposition / copying of a double matrix
AB := alpha *op( AB ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation. |
void |
domatadd(TTrans transa,
TTrans transb,
int m,
int n,
double alpha,
double[] A,
int lda,
double beta,
double[] B,
int ldb,
double[] C,
int ldc)
Scales and adds two doubles matrices, as well as performing out-of-place
transposition operations
C := alpha *op(A) + beta *op(B) where
the op() operations are transpose, conjugate-transpose, conjugate
(no transpose), or no transpose, depending on the values of
transa and transb. |
void |
domatcopy(TTrans trans,
int rows,
int cols,
double alpha,
double[] A,
int lda,
double[] B,
int ldb)
Scaling and out-of-place transposition / copying of a double matrix
B := alpha *op( A ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation. |
static BlasExt |
getInstance() |
void |
simatcopy(TTrans trans,
int rows,
int cols,
float alpha,
float[] AB,
int lda,
int ldb)
Scaling and in-place transposition / copying of a float matrix
AB := alpha *op( AB ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation. |
void |
somatadd(TTrans transa,
TTrans transb,
int m,
int n,
float alpha,
float[] A,
int lda,
float beta,
float[] B,
int ldb,
float[] C,
int ldc)
Scales and adds two float matrices, as well as performing out-of-place
transposition operations
C := alpha *op(A) + beta *op(B) where
the op() operations are transpose, conjugate-transpose, conjugate
(no transpose), or no transpose, depending on the values of
transa and transb. |
void |
somatcopy(TTrans trans,
int rows,
int cols,
float alpha,
float[] A,
int lda,
float[] B,
int ldb)
Scaling and out-of-place transposition / copying of a float matrix
B := alpha *op( A ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation. |
void |
zgemm3m(Trans transa,
Trans transb,
int m,
int n,
int k,
double alphar,
double alphai,
double[] a,
int lda,
double[] b,
int ldb,
double betar,
double betai,
double[] c,
int ldc) |
void |
zimatcopy(TTrans trans,
int rows,
int cols,
double alphar,
double alphai,
double[] AB,
int lda,
int ldb)
Scaling and in-place transposition / copying of a double precision
complex matrix
AB := alpha *op( AB ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation. |
void |
zomatadd(TTrans transa,
TTrans transb,
int m,
int n,
double alphar,
double alphai,
double[] A,
int lda,
double betar,
double betai,
double[] B,
int ldb,
double[] C,
int ldc)
Scales and adds two double precision complex matrices, as well as
performing out-of-place transposition operations
C := alpha *op(A) + beta *op(B) where the op() operations
are transpose, conjugate-transpose, conjugate (no transpose), or no
transpose, depending on the values of transa and transb. |
void |
zomatcopy(TTrans trans,
int rows,
int cols,
double alphar,
double alphai,
double[] A,
int lda,
double[] B,
int ldb)
Scaling and out-of-place transposition / copying of a double precision
complex matrix
B := alpha *op( A ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation. |
public static BlasExt getInstance()
public final void cgemm3m(Trans transa, Trans transb, int m, int n, int k, float alphar, float alphai, float[] a, int lda, float[] b, int ldb, float betar, float betai, float[] c, int ldc)
public final void zgemm3m(Trans transa, Trans transb, int m, int n, int k, double alphar, double alphai, double[] a, int lda, double[] b, int ldb, double betar, double betai, double[] c, int ldc)
public final void simatcopy(TTrans trans, int rows, int cols, float alpha, float[] AB, int lda, int ldb)
AB := alpha *op( AB ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix AB before the transpose
operationcols - the number of columns in matrix AB before the
transpose operationalpha - this parameter scales the input matrix by alphaAB - the input matrix modified in-placelda - distance between the first elements in adjacent columns in the
source matrix; measured in the number of elements (this
parameter must be at least rows)ldb - distance between the first elements in adjacent columns in the
destination matrix; measured in the number of elements. If
trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void dimatcopy(TTrans trans, int rows, int cols, double alpha, double[] AB, int lda, int ldb)
AB := alpha *op( AB ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix AB before the transpose
operationcols - the number of columns in matrix AB before the
transpose operationalpha - this parameter scales the input matrix by alphaAB - the input matrix modified in-placelda - distance between the first elements in adjacent columns in the
source matrix; measured in the number of elements (this
parameter must be at least rows)ldb - distance between the first elements in adjacent columns in the
destination matrix; measured in the number of elements. If
trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void cimatcopy(TTrans trans, int rows, int cols, float alphar, float alphai, float[] AB, int lda, int ldb)
AB := alpha *op( AB ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix AB before the transpose
operationcols - the number of columns in matrix AB before the
transpose operationalphar - the real part of the scale factor for the input matrixalphai - the imaginary part of the scale factor for the input matrixAB - the input matrix modified in-placelda - distance between the first elements in adjacent columns in the
source matrix; measured in the number of elements (this
parameter must be at least rows)ldb - distance between the first elements in adjacent columns in the
destination matrix; measured in the number of elements. If
trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void zimatcopy(TTrans trans, int rows, int cols, double alphar, double alphai, double[] AB, int lda, int ldb)
AB := alpha *op( AB ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix AB before the transpose
operationcols - the number of columns in matrix AB before the
transpose operationalphar - the real part of the scale factor for the input matrixalphai - the imaginary part of the scale factor for the input matrixAB - the input matrix modified in-placelda - distance between the first elements in adjacent columns in the
source matrix; measured in the number of elements (this
parameter must be at least rows)ldb - distance between the first elements in adjacent columns in the
destination matrix; measured in the number of elements. If
trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void somatcopy(TTrans trans, int rows, int cols, float alpha, float[] A, int lda, float[] B, int ldb)
B := alpha *op( A ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix A (the source matrix)cols - the number of columns in matrix A (the source matrix)alpha - this parameter scales the input matrix by alphaA - the input matrix, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix (A); measured in the number of elements
(this parameter must be at least rows)B - the output matrix, modifiedldb - distance between the first elements in adjacent columns in the
destination matrix (B); measured in the number of
elements. If trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void domatcopy(TTrans trans, int rows, int cols, double alpha, double[] A, int lda, double[] B, int ldb)
B := alpha *op( A ) where the transposition operation
op() can be a normal matrix copy, a transposition, a conjugate
transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix A (the source matrix)cols - the number of columns in matrix A (the source matrix)alpha - this parameter scales the input matrix by alphaA - the input matrix, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix (A); measured in the number of elements
(this parameter must be at least rows)B - the output matrix, modifiedldb - distance between the first elements in adjacent columns in the
destination matrix (B); measured in the number of
elements. If trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void comatcopy(TTrans trans, int rows, int cols, float alphar, float alphai, float[] A, int lda, float[] B, int ldb)
B := alpha *op( A ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix A (the source matrix)cols - the number of columns in matrix A (the source matrix)alphar - the real part of the scale factor for the input matrixalphai - the imaginary part of the scale factor for the input matrixA - the input matrix, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix (A); measured in the number of elements
(this parameter must be at least rows)B - the output matrix, modifiedldb - distance between the first elements in adjacent columns in the
destination matrix (B); measured in the number of
elements. If trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void zomatcopy(TTrans trans, int rows, int cols, double alphar, double alphai, double[] A, int lda, double[] B, int ldb)
B := alpha *op( A ) where the transposition
operation op() can be a normal matrix copy, a transposition, a
conjugate transposition, or just a conjugation.trans - specifies the operation typerows - the number of rows in matrix A (the source matrix)cols - the number of columns in matrix A (the source matrix)alphar - the real part of the scale factor for the input matrixalphai - the imaginary part of the scale factor for the input matrixA - the input matrix, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix (A); measured in the number of elements
(this parameter must be at least rows)B - the output matrix, modifiedldb - distance between the first elements in adjacent columns in the
destination matrix (B); measured in the number of
elements. If trans is TTrans.TRANS or
TTrans.CONJ_TRANS, this parameter must be at least
max(1, cols); otherwise it must be at least
max(1, rows)public final void somatadd(TTrans transa, TTrans transb, int m, int n, float alpha, float[] A, int lda, float beta, float[] B, int ldb, float[] C, int ldc)
C := alpha *op(A) + beta *op(B) where
the op() operations are transpose, conjugate-transpose, conjugate
(no transpose), or no transpose, depending on the values of
transa and transb. If no transposition of the source
matrices is required, m is the number of rows and n is
the number of columns in the source matrices A and B. In
this case, the output matrix C is m x n.transa - specifies the operation type for matrix Atransb - specifies the operation type for matrix Bm - the number of matrix rows in op(A), op(B), and
Cn - the number of matrix columns in op(A), op(B), and
Calpha - this parameter scales the input matrix A by
alphaA - the input matrix A, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix A; measured in the number of elements.
If transa is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)beta - this parameter scales the input matrix B by
betaB - the input matrix B, unmodifiedldb - distance between the first elements in adjacent columns in the
source matrix B; measured in the number of elements.
If transb is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)C - the output matrix, modifiedldc - distance between the first elements in adjacent columns in the
destination matrix C; measured in the number of
elements (it must be at least max(1, m))public final void domatadd(TTrans transa, TTrans transb, int m, int n, double alpha, double[] A, int lda, double beta, double[] B, int ldb, double[] C, int ldc)
C := alpha *op(A) + beta *op(B) where
the op() operations are transpose, conjugate-transpose, conjugate
(no transpose), or no transpose, depending on the values of
transa and transb. If no transposition of the source
matrices is required, m is the number of rows and n is
the number of columns in the source matrices A and B. In
this case, the output matrix C is m x n.transa - specifies the operation type for matrix Atransb - specifies the operation type for matrix Bm - the number of matrix rows in op(A), op(B), and
Cn - the number of matrix columns in op(A), op(B), and
Calpha - this parameter scales the input matrix A by
alphaA - the input matrix A, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix A; measured in the number of elements.
If transa is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)beta - this parameter scales the input matrix B by
betaB - the input matrix B, unmodifiedldb - distance between the first elements in adjacent columns in the
source matrix B; measured in the number of elements.
If transb is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)C - the output matrix, modifiedldc - distance between the first elements in adjacent columns in the
destination matrix C; measured in the number of
elements (it must be at least max(1, m))public final void comatadd(TTrans transa, TTrans transb, int m, int n, float alphar, float alphai, float[] A, int lda, float betar, float betai, float[] B, int ldb, float[] C, int ldc)
C := alpha *op(A) + beta *op(B) where the op() operations
are transpose, conjugate-transpose, conjugate (no transpose), or no
transpose, depending on the values of transa and transb.
If no transposition of the source matrices is required, m is the
number of rows and n is the number of columns in the source
matrices A and B. In this case, the output matrix
C is m x n.transa - specifies the operation type for matrix Atransb - specifies the operation type for matrix Bm - the number of matrix rows in op(A), op(B), and
Cn - the number of matrix columns in op(A), op(B), and
Calphar - the real part of the scale factor for the input matrix
Aalphai - the imaginary part of the scale factor for the input matrix
AA - the input matrix A, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix A; measured in the number of elements.
If transa is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)betar - the real part of the scale factor for the input matrix
Bbetai - the imaginary part of the scale factor for the input matrix
BB - the input matrix B, unmodifiedldb - distance between the first elements in adjacent columns in the
source matrix B; measured in the number of elements.
If transb is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)C - the output matrix, modifiedldc - distance between the first elements in adjacent columns in the
destination matrix C; measured in the number of
elements (it must be at least max(1, m))public final void zomatadd(TTrans transa, TTrans transb, int m, int n, double alphar, double alphai, double[] A, int lda, double betar, double betai, double[] B, int ldb, double[] C, int ldc)
C := alpha *op(A) + beta *op(B) where the op() operations
are transpose, conjugate-transpose, conjugate (no transpose), or no
transpose, depending on the values of transa and transb.
If no transposition of the source matrices is required, m is the
number of rows and n is the number of columns in the source
matrices A and B. In this case, the output matrix
C is m x n.transa - specifies the operation type for matrix Atransb - specifies the operation type for matrix Bm - the number of matrix rows in op(A), op(B), and
Cn - the number of matrix columns in op(A), op(B), and
Calphar - the real part of the scale factor for the input matrix
Aalphai - the imaginary part of the scale factor for the input matrix
AA - the input matrix A, unmodifiedlda - distance between the first elements in adjacent columns in the
source matrix A; measured in the number of elements.
If transa is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)betar - the real part of the scale factor for the input matrix
Bbetai - the imaginary part of the scale factor for the input matrix
BB - the input matrix B, unmodifiedldb - distance between the first elements in adjacent columns in the
source matrix B; measured in the number of elements.
If transb is TTrans.NO_TRANS or
TTrans.CONJ, this parameter must be at least
max(1, m); otherwise it must be max(1, n)C - the output matrix, modifiedldc - distance between the first elements in adjacent columns in the
destination matrix C; measured in the number of
elements (it must be at least max(1, m))Copyright © 2023. All rights reserved.