net.dedekind.blas

Class BlasExt

java.lang.Object

net.dedekind.blas.BlasExt

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.

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	BlasExt()

Method Summary

Methods

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.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

BlasExt

protected BlasExt()

Method Detail

getInstance

public static BlasExt getInstance()

cgemm3m

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)

zgemm3m

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)

simatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - the number of rows in matrix AB before the transpose operation

cols - the number of columns in matrix AB before the transpose operation

alpha - this parameter scales the input matrix by alpha

AB - the input matrix modified in-place

lda - 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)

dimatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - the number of rows in matrix AB before the transpose operation

cols - the number of columns in matrix AB before the transpose operation

alpha - this parameter scales the input matrix by alpha

AB - the input matrix modified in-place

lda - 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)

cimatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - the number of rows in matrix AB before the transpose operation

cols - the number of columns in matrix AB before the transpose operation

alphar - the real part of the scale factor for the input matrix

alphai - the imaginary part of the scale factor for the input matrix

AB - the input matrix modified in-place

lda - 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)

zimatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - the number of rows in matrix AB before the transpose operation

cols - the number of columns in matrix AB before the transpose operation

alphar - the real part of the scale factor for the input matrix

alphai - the imaginary part of the scale factor for the input matrix

AB - the input matrix modified in-place

lda - 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)

somatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - 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 alpha

A - the input matrix, unmodified

lda - 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, modified

ldb - 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)

domatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - 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 alpha

A - the input matrix, unmodified

lda - 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, modified

ldb - 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)

comatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - 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 matrix

alphai - the imaginary part of the scale factor for the input matrix

A - the input matrix, unmodified

lda - 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, modified

ldb - 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)

zomatcopy

public final 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.

Parameters:

trans - specifies the operation type

rows - 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 matrix

alphai - the imaginary part of the scale factor for the input matrix

A - the input matrix, unmodified

lda - 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, modified

ldb - 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)

somatadd

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)

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. 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.

Parameters:

transa - specifies the operation type for matrix A

transb - specifies the operation type for matrix B

m - the number of matrix rows in op(A), op(B), and C

n - the number of matrix columns in op(A), op(B), and C

alpha - this parameter scales the input matrix A by alpha

A - the input matrix A, unmodified

lda - 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 beta

B - the input matrix B, unmodified

ldb - 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, modified

ldc - 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))

domatadd

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)

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. 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.

Parameters:

transa - specifies the operation type for matrix A

transb - specifies the operation type for matrix B

m - the number of matrix rows in op(A), op(B), and C

n - the number of matrix columns in op(A), op(B), and C

alpha - this parameter scales the input matrix A by alpha

A - the input matrix A, unmodified

lda - 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 beta

B - the input matrix B, unmodified

ldb - 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, modified

ldc - 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))

comatadd

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)

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. 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.

Parameters:

transa - specifies the operation type for matrix A

transb - specifies the operation type for matrix B

m - the number of matrix rows in op(A), op(B), and C

n - the number of matrix columns in op(A), op(B), and C

alphar - the real part of the scale factor for the input matrix A

alphai - the imaginary part of the scale factor for the input matrix A

A - the input matrix A, unmodified

lda - 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 B

betai - the imaginary part of the scale factor for the input matrix B

B - the input matrix B, unmodified

ldb - 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, modified

ldc - 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))

zomatadd

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)

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. 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.

Parameters:

transa - specifies the operation type for matrix A

transb - specifies the operation type for matrix B

m - the number of matrix rows in op(A), op(B), and C

n - the number of matrix columns in op(A), op(B), and C

alphar - the real part of the scale factor for the input matrix A

alphai - the imaginary part of the scale factor for the input matrix A

A - the input matrix A, unmodified

lda - 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 B

betai - the imaginary part of the scale factor for the input matrix B

B - the input matrix B, unmodified

ldb - 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, modified

ldc - 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))