BLAS Level 3 Complex

Functions
iclblasStatus_t	iclblasCgemm (iclblasHandle_t handle, iclblasOperation_t transa, iclblasOperation_t transb, int m, int n, int k, const oclComplex_t *alpha, oclComplex_t *A, int lda, oclComplex_t *B, int ldb, const oclComplex_t *beta, oclComplex_t *C, int ldc)
	Performs matrix by matrix multiplication. More...
iclblasStatus_t	iclblasCsymm (iclblasHandle_t handle, iclblasSideMode_t side, iclblasFillMode_t uplo, int m, int n, const oclComplex_t *alpha, oclComplex_t *A, int lda, oclComplex_t *B, int ldb, const oclComplex_t *beta, oclComplex_t *C, int ldc)
	Performs symmetric matrix by matrix multiplication. More...
iclblasStatus_t	iclblasCsyr2k (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, int n, int k, const oclComplex_t *alpha, oclComplex_t *A, int lda, oclComplex_t *B, int ldb, const oclComplex_t *beta, oclComplex_t *C, int ldc)
	Performs symmetric rank-2k update. More...
iclblasStatus_t	iclblasCsyrk (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, int n, int k, const oclComplex_t *alpha, oclComplex_t *A, int lda, const oclComplex_t *beta, oclComplex_t *C, int ldc)
	Performs symmetric rank-k update. More...
iclblasStatus_t	iclblasCtrsm (iclblasHandle_t handle, iclblasSideMode_t side, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int m, int n, const oclComplex_t *alpha, oclComplex_t *A, int lda, oclComplex_t *B, int ldb)
	Solves triangular linear system with multiple right-hand-sides. More...
iclblasStatus_t	iclblasCherk (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, int n, int k, const float *alpha, oclComplex_t *A, int lda, const float *beta, oclComplex_t *C, int ldc)
	Performs Hermitian rank-k update. More...
iclblasStatus_t	iclblasCher2k (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, int n, int k, const oclComplex_t *alpha, oclComplex_t *A, int lda, oclComplex_t *B, int ldb, const float *beta, oclComplex_t *C, int ldc)
	Performs Hermitian rank-2k update. More...
iclblasStatus_t	iclblasCtrmm (iclblasHandle_t handle, iclblasSideMode_t side, iclblasFillMode_t uplo, iclblasOperation_t transa, iclblasDiagType_t diag, int m, int n, const oclComplex_t *alpha, oclComplex_t *A, int lda, oclComplex_t *B, int ldb, oclComplex_t *C, int ldc)
	Performs triangular matrix by matrix multiplication. More...
iclblasStatus_t	iclblasChemm (iclblasHandle_t handle, iclblasSideMode_t side, iclblasFillMode_t uplo, int m, int n, const oclComplex_t *alpha, oclComplex_t *A, int lda, oclComplex_t *B, int ldb, const oclComplex_t *beta, oclComplex_t *C, int ldc)
	Performs Hermitian matrix by matrix multiplication. More...

Detailed Description

Function Documentation

iclblasCgemm()

iclblasStatus_t iclblasCgemm	(	iclblasHandle_t	handle,
		iclblasOperation_t	transa,
		iclblasOperation_t	transb,
		int	m,
		int	n,
		int	k,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	B,
		int	ldb,
		const oclComplex_t *	beta,
		oclComplex_t *	C,
		int	ldc
	)

Performs matrix by matrix multiplication.

C = alpha * op(A) * op(B) + beta * C

Where alpha and beta are scalars and A, B and C are matrices with dimmensions m x k for op(A), k x n for op(B) and m x n for C.

Additionally operation on matrix A is specified by transa value as followed:

op(A) = A     if transa == ICLBLAS_OP_N
op(A) = A^T   if transa == ICLBLAS_OP_T
op(A) = A^H   if transa == ICLBLAS_OP_C

Additionally operation on matrix B is specified by transb value as followed:

op(B) = B     if transb == ICLBLAS_OP_N
op(B) = B^T   if transb == ICLBLAS_OP_T
op(B) = B^H   if transb == ICLBLAS_OP_C

Parameters

[in]	handle	handle to the library context
[in]	transa	indicates operation op(A) for matrix A
[in]	transb	indicates operation op(B) for matrix B
[in]	m	number of rows in op(A) and C
[in]	n	number of columns in op(B) and C
[in]	k	number of columns in op(A) and rows in op(B)
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x k] where lda is at least max (1, m) if transa == ICLBLAS_OP_N and [lda x m] where lda is at least max (1, k) if transa == ICLBLAS_OP_T || transa == ICLBLAS_OP_C
[in]	lda	first dimension of matrix A
[in]	B	array of size [ldb x n] where ldb is at least max (1, k) if transb == ICLBLAS_OP_N and [ldb x k] where ldb is at least max (1, n) if transb == ICLBLAS_OP_T || transb == ICLBLAS_OP_C
[in]	ldb	first dimension of matrix B; must be at least max(1, m)
[in]	beta	scalar used in multiplication; if beta == 0, C does not have to be initialized
[in,out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, m)

iclblasChemm()

iclblasStatus_t iclblasChemm	(	iclblasHandle_t	handle,
		iclblasSideMode_t	side,
		iclblasFillMode_t	uplo,
		int	m,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	B,
		int	ldb,
		const oclComplex_t *	beta,
		oclComplex_t *	C,
		int	ldc
	)

Performs Hermitian matrix by matrix multiplication.

alpha * A * B + beta * C  if side == ICLBLAS_SIDE_LEFT
alpha * B * A + beta * C  if side == ICLBLAS_SIDE_RIGHT

Where alpha and beta are scalars, B and C are m x n matrices, and A is Hermitian matrix in lower or upper mode.

Parameters

[in]	handle	handle to the library context
[in]	side	indicates right or left sided multiplication of matrix A and B
[in]	uplo	indicates if lower or upper part of matrix is stored in A
[in]	m	number of rows in B and C
[in]	n	number of columns in B and C
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x m] where lda is at least max (1, m) if side == ICLBLAS_SIDE_LEFT and [lda x n] where lda is at least max (1, n) if side == ICLBLAS_SIDE_RIGHT
[in]	lda	first dimension of matrix A
[in]	B	array of size [ldb x n]
[in]	ldb	first dimension of matrix B; must be at least max(1, m)
[in]	beta	scalar used in multiplication; if beta == 0, C does not have to be initialized
[in,out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, m)

iclblasCher2k()

iclblasStatus_t iclblasCher2k	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		int	n,
		int	k,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	B,
		int	ldb,
		const float *	beta,
		oclComplex_t *	C,
		int	ldc
	)

Performs Hermitian rank-2k update.

C = alpha * op(A) * op(B)^H + \conjugate{alpha} * op(B) * op(A)^H + beta * C

Where alpha and beta are scalars, op(A) and op(B) are n x k and C is Hermitian matrix in lower or upper mode.

Additionally operation on matrix A is specified by trans value as followed:

op(A) = A     if trans == ICLBLAS_OP_N
op(A) = A^H   if trans == ICLBLAS_OP_C

Additionally operation on matrix B is specified by trans value as followed:

op(B) = B     if trans == ICLBLAS_OP_N
op(B) = B^H   if trans == ICLBLAS_OP_C

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if lower or upper part of matrix is stored in C
[in]	trans	indicates operation op(A) and op(B) for matrix A and B
[in]	n	number of rows in op(A), op(B) and C
[in]	k	number of columns in op(A) and op(B)
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x k] where lda is at least max (1, n) if trans == ICLBLAS_OP_N and [lda x n] where lda is at least max (1, k) if side == ICLBLAS_OP_C
[in]	lda	first dimension of matrix A
[in]	B	array of size [ldb x k] where ldb is at least max (1, n) if trans == ICLBLAS_OP_N and [ldb x n] where lda is at least max (1, k) if side == ICLBLAS_OP_C
[in]	ldb	first dimension of matrix B
[in]	beta	scalar used in multiplication; if beta == 0, C does not have to be initialized
[in,out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, n)

iclblasCherk()

iclblasStatus_t iclblasCherk	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		int	n,
		int	k,
		const float *	alpha,
		oclComplex_t *	A,
		int	lda,
		const float *	beta,
		oclComplex_t *	C,
		int	ldc
	)

Performs Hermitian rank-k update.

C = alpha * op(A) * op(A)^H + beta * C

Where alpha and beta are scalars, op(A) is n x k and C is Hermitian matrix in lower or upper mode.

Additionally operation on matrix A is specified by trans value as followed:

op(A) = A     if trans == ICLBLAS_OP_N
op(A) = A^H   if trans == ICLBLAS_OP_C

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if lower or upper part of matrix is stored in C
[in]	trans	indicates operation op(A) for matrix A
[in]	n	number of rows in op(A) and C
[in]	k	number of columns in op(A)
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x k] where lda is at least max (1, n) if trans == ICLBLAS_OP_N and [lda x n] where lda is at least max (1, k) if side == ICLBLAS_OP_C
[in]	lda	first dimension of matrix A
[in]	beta	scalar used in multiplication; if beta == 0, C does not have to be initialized
[in,out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, n)

iclblasCsymm()

iclblasStatus_t iclblasCsymm	(	iclblasHandle_t	handle,
		iclblasSideMode_t	side,
		iclblasFillMode_t	uplo,
		int	m,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	B,
		int	ldb,
		const oclComplex_t *	beta,
		oclComplex_t *	C,
		int	ldc
	)

Performs symmetric matrix by matrix multiplication.

y = alpha * A * B + beta * C  if side == ICLBLAS_SIDE_LEFT
y = alpha * B * A + beta * C  if side == ICLBLAS_SIDE_RIGHT

Where alpha and beta are scalars, B and C are n x m element matrices and A is symmetric matrix in lower or upper mode.

Parameters

[in]	handle	handle to the library context
[in]	side	indicates right or left sided multiplication of matrix A and B
[in]	uplo	indicates if lower or upper part of matrix is stored in A
[in]	m	number of rows in B and C
[in]	n	number of columns in B and C
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x m] where lda is at least max (1, m) if side == ICLBLAS_SIDE_LEFT and [lda x n] where lda is at least max (1, n) if side == ICLBLAS_SIDE_RIGHT
[in]	lda	first dimension of matrix A
[in]	B	array of size [ldb x n]
[in]	ldb	first dimension of matrix B; must be at least max(1, m)
[in]	beta	scalar used in multiplication; if beta == 0, C does not have to be initialized
[in,out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, m)

iclblasCsyr2k()

iclblasStatus_t iclblasCsyr2k	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		int	n,
		int	k,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	B,
		int	ldb,
		const oclComplex_t *	beta,
		oclComplex_t *	C,
		int	ldc
	)

Performs symmetric rank-2k update.

C = alpha * (op(A) * op(B)^T + op(B) * op(A)^T) + beta * C

Where alpha and beta are scalars, op(A) and op(B) are n x k and C is symmetric matrix in lower or upper mode.

Additionally operation on matrix A is specified by trans value as followed:

op(A) = A     if trans == ICLBLAS_OP_N
op(A) = A^T   if trans == ICLBLAS_OP_T

Additionally operation on matrix B is specified by trans value as followed:

op(B) = B     if trans == ICLBLAS_OP_N
op(B) = B^T   if trans == ICLBLAS_OP_T

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if lower or upper part of matrix is stored in C
[in]	trans	indicates operation op(A) and op(B) for matrix A and B
[in]	n	number of rows in op(A), op(B) and C
[in]	k	number of columns in op(A) and op(B)
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x k] where lda is at least max (1, n) if trans == ICLBLAS_OP_N and [lda x n] where lda is at least max (1, k) if side == ICLBLAS_OP_T
[in]	lda	first dimension of matrix A
[in]	B	array of size [ldb x k] where ldb is at least max (1, n) if trans == ICLBLAS_OP_N and [ldb x n] where lda is at least max (1, k) if side == ICLBLAS_OP_T
[in]	ldb	first dimension of matrix B
[in]	beta	scalar used in multiplication; if beta == 0, C does not have to be initialized
[in,out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, n)

iclblasCsyrk()

iclblasStatus_t iclblasCsyrk	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		int	n,
		int	k,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		const oclComplex_t *	beta,
		oclComplex_t *	C,
		int	ldc
	)

Performs symmetric rank-k update.

C = alpha * op(A) * op(A)^T + beta * C

Where alpha and beta are scalars, op(A) is n x k and C is symmetric matrix in lower or upper mode.

Additionally operation on matrix A is specified by trans value as followed:

op(A) = A     if trans == ICLBLAS_OP_N
op(A) = A^T   if trans == ICLBLAS_OP_T

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if lower or upper part of matrix is stored in C
[in]	trans	indicates operation op(A) for matrix A
[in]	n	number of rows in op(A) and C
[in]	k	number of columns in op(A)
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x k] where lda is at least max (1, n) if trans == ICLBLAS_OP_N and [lda x n] where lda is at least max (1, k) if side == ICLBLAS_OP_T
[in]	lda	first dimension of matrix A
[in]	beta	scalar used in multiplication; if beta == 0, C does not have to be initialized
[in,out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, n)

iclblasCtrmm()

iclblasStatus_t iclblasCtrmm	(	iclblasHandle_t	handle,
		iclblasSideMode_t	side,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	transa,
		iclblasDiagType_t	diag,
		int	m,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	B,
		int	ldb,
		oclComplex_t *	C,
		int	ldc
	)

Performs triangular matrix by matrix multiplication.

C = alpha * op(A) * B  if side == ICLBLAS_SIDE_LEFT
C = alpha * B * op(A)  if side == ICLBLAS_SIDE_RIGHT

Where alpha is scalars, B and C are m x n matrices, and A is triangular matrix in lower or upper mode with or without main diagonal.

Additionally operation on matrix B is specified by transa value as followed:

op(A) = A     if transa == ICLBLAS_OP_N
op(A) = A^T   if transa == ICLBLAS_OP_T
op(A) = A^H   if transa == ICLBLAS_OP_C

Parameters

[in]	handle	handle to the library context
[in]	side	indicates right or left sided multiplication of matrix A and B
[in]	uplo	indicates if lower or upper part of matrix is stored in A
[in]	transa	indicates operation op(A) for matrix A
[in]	diag	indicates if main diagonal of matrix A is unitary or not
[in]	m	number of rows in B
[in]	n	number of columns in B
[in]	alpha	scalar used in multiplication; if alpha == 0, A and B do not have to be initialized
[in]	A	array of size [lda x m] where lda is at least max (1, m) if side == ICLBLAS_SIDE_LEFT and [lda x n] where lda is at least max (1, n) if side == ICLBLAS_SIDE_RIGHT
[in]	lda	first dimension of matrix A
[in]	B	array of size [ldb x n]
[in]	ldb	first dimension of matrix B; must be at least max(1, m)
[out]	C	array of size [ldc x n]
[in]	ldc	first dimension of matrix C; must be at least max(1, m)

iclblasCtrsm()

iclblasStatus_t iclblasCtrsm	(	iclblasHandle_t	handle,
		iclblasSideMode_t	side,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	m,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	B,
		int	ldb
	)

Solves triangular linear system with multiple right-hand-sides.

op(A) * X = alpha * B  if side == ICLBLAS_SIDE_LEFT
X * op(A) = alpha * B  if side == ICLBLAS_SIDE_RIGHT

Where alpha is scalars, X and B are m x n matrices, and A is triangular matrix in lower or upper mode with or without main diagonal.

Additionally operation on matrix A is specified by trans value as followed:

op(A) = A     if trans == ICLBLAS_OP_N
op(A) = A^T   if trans == ICLBLAS_OP_T
op(A) = A^H   if trans == ICLBLAS_OP_C

The solution X is overwritten on B on exit.

Parameters

[in]	handle	handle to the library context
[in]	side	indicates right or left sided multiplication of matrix A and X
[in]	uplo	indicates if lower or upper part of matrix is stored in A
[in]	trans	indicates operation op(A) for matrix A
[in]	diag	indicates if main diagonal of matrix A is unitary or not
[in]	m	number of rows in B
[in]	n	number of columns in B
[in]	alpha	scalar used in multiplication; if alpha == 0, A and B do not have to be initialized
[in]	A	array of size [lda x m] where lda is at least max (1, m) if side == ICLBLAS_SIDE_LEFT and [lda x n] where lda is at least max (1, n) if side == ICLBLAS_SIDE_RIGHT
[in]	lda	first dimension of matrix A
[in,out]	B	array of size [ldb x n]
[in]	ldb	first dimension of matrix B; must be at least max(1, m)