Functions
iclblasStatus_t	iclblasSsymm (iclblasHandle_t handle, iclblasSideMode_t side, iclblasFillMode_t uplo, int m, int n, const float alpha, float A, int lda, float B, int ldb, const float beta, float *C, int ldc)
	Performs symmetric matrix by matrix multiplication. More...

iclblasStatus_t	iclblasSsyrk (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, int n, int k, const float alpha, float A, int lda, const float beta, float C, int ldc)
	Performs symmetric rank-k update. More...

iclblasStatus_t	iclblasSsyr2k (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, int n, int k, const float alpha, float A, int lda, float B, int ldb, const float beta, float *C, int ldc)
	Performs symmetric rank-2k update. More...

iclblasStatus_t	iclblasSgemm (iclblasHandle_t handle, iclblasOperation_t transa, iclblasOperation_t transb, int m, int n, int k, const float alpha, float A, int lda, float B, int ldb, const float beta, float *C, int ldc)
	Performs matrix by matrix multiplication. More...

iclblasStatus_t	iclblasStrsm (iclblasHandle_t handle, iclblasSideMode_t side, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int m, int n, const float alpha, float A, int lda, float *B, int ldb)
	Solves triangular linear system with multiple right-hand-sides. More...

iclblasStatus_t	iclblasStrmm (iclblasHandle_t handle, iclblasSideMode_t side, iclblasFillMode_t uplo, iclblasOperation_t transa, iclblasDiagType_t diag, int m, int n, const float alpha, float A, int lda, float B, int ldb, float C, int ldc)
	Performs triangular matrix by matrix multiplication. More...

Detailed Description

Function Documentation

◆ iclblasSgemm()

iclblasStatus_t iclblasSgemm	(	iclblasHandle_t	handle,
		iclblasOperation_t	transa,
		iclblasOperation_t	transb,
		int	m,
		int	n,
		int	k,
		const float *	alpha,
		float *	A,
		int	lda,
		float *	B,
		int	ldb,
		const float *	beta,
		float *	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)

◆ iclblasSsymm()

iclblasStatus_t iclblasSsymm	(	iclblasHandle_t	handle,
		iclblasSideMode_t	side,
		iclblasFillMode_t	uplo,
		int	m,
		int	n,
		const float *	alpha,
		float *	A,
		int	lda,
		float *	B,
		int	ldb,
		const float *	beta,
		float *	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)

◆ iclblasSsyr2k()

iclblasStatus_t iclblasSsyr2k	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		int	n,
		int	k,
		const float *	alpha,
		float *	A,
		int	lda,
		float *	B,
		int	ldb,
		const float *	beta,
		float *	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)

◆ iclblasSsyrk()

iclblasStatus_t iclblasSsyrk	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		int	n,
		int	k,
		const float *	alpha,
		float *	A,
		int	lda,
		const float *	beta,
		float *	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.

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

◆ iclblasStrmm()

iclblasStatus_t iclblasStrmm	(	iclblasHandle_t	handle,
		iclblasSideMode_t	side,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	transa,
		iclblasDiagType_t	diag,
		int	m,
		int	n,
		const float *	alpha,
		float *	A,
		int	lda,
		float *	B,
		int	ldb,
		float *	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 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

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)

◆ iclblasStrsm()

iclblasStatus_t iclblasStrsm	(	iclblasHandle_t	handle,
		iclblasSideMode_t	side,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	m,
		int	n,
		const float *	alpha,
		float *	A,
		int	lda,
		float *	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)

Functions

Detailed Description

Function Documentation

◆ iclblasSgemm()

◆ iclblasSsymm()

◆ iclblasSsyr2k()

◆ iclblasSsyrk()

◆ iclblasStrmm()

◆ iclblasStrsm()