Functions
iclblasStatus_t	iclblasCgbmv (iclblasHandle_t handle, iclblasOperation_t trans, int m, int n, int kl, int ku, const oclComplex_t alpha, oclComplex_t A, int lda, oclComplex_t x, int incx, const oclComplex_t beta, oclComplex_t *y, int incy)
	Performs general banded matrix by vector multiplication. More...

iclblasStatus_t	iclblasCgeru (iclblasHandle_t handle, int m, int n, const oclComplex_t alpha, oclComplex_t x, int incx, oclComplex_t y, int incy, oclComplex_t A, int lda)
	Performs general matrix rank 1 update. More...

iclblasStatus_t	iclblasCgerc (iclblasHandle_t handle, int m, int n, const oclComplex_t alpha, oclComplex_t x, int incx, oclComplex_t y, int incy, oclComplex_t A, int lda)
	Performs general matrix rank 1 update. More...

iclblasStatus_t	iclblasCgemv (iclblasHandle_t handle, iclblasOperation_t trans, int m, int n, const oclComplex_t alpha, oclComplex_t A, int lda, oclComplex_t x, int incx, const oclComplex_t beta, oclComplex_t *y, int incy)
	Performs general matrix by vector multiplication. More...

iclblasStatus_t	iclblasCher (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, const float alpha, oclComplex_t x, int incx, oclComplex_t *A, int lda)
	Performs Hermitian matrix rank 1 update. More...

iclblasStatus_t	iclblasChemv (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, const oclComplex_t alpha, oclComplex_t A, int lda, oclComplex_t x, int incx, const oclComplex_t beta, oclComplex_t *y, int incy)
	Performs Hermitian matrix by vector multiplication. More...

iclblasStatus_t	iclblasCtrmv (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int n, oclComplex_t A, int lda, oclComplex_t x, int incx)
	Performs triangular matrix by vector multiplication. More...

iclblasStatus_t	iclblasCher2 (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, const oclComplex_t alpha, oclComplex_t x, int incx, oclComplex_t y, int incy, oclComplex_t A, int lda)
	Performs Hermitian matrix rank 2 update. More...

iclblasStatus_t	iclblasChpmv (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, const oclComplex_t alpha, oclComplex_t AP, oclComplex_t x, int incx, const oclComplex_t beta, oclComplex_t *y, int incy)
	Performs packed Hermitian matrix by vector multiplication. More...

iclblasStatus_t	iclblasChpr (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, const float alpha, oclComplex_t x, int incx, oclComplex_t *AP)
	Performs packed Hermitian matrix rank 1 update. More...

iclblasStatus_t	iclblasChpr2 (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, const oclComplex_t alpha, oclComplex_t x, int incx, oclComplex_t y, int incy, oclComplex_t AP)
	Performs packed Hermitian matrix rank 2 update. More...

iclblasStatus_t	iclblasCtpmv (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int n, oclComplex_t AP, oclComplex_t x, int incx)
	Performs packed triangular matrix by vector multiplication. More...

iclblasStatus_t	iclblasCtbmv (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int n, int k, oclComplex_t A, int lda, oclComplex_t x, int incx)
	Performs triangular banded matrix by vector multiplication. More...

iclblasStatus_t	iclblasCtbsv (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int n, int k, oclComplex_t A, int lda, oclComplex_t x, int incx)
	Solves triangular banded linear system with single right-hand side. More...

iclblasStatus_t	iclblasCtrsv (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int n, oclComplex_t A, int lda, oclComplex_t x, int incx)
	Solves triangular linear system with single right-hand side. More...

iclblasStatus_t	iclblasCtpsv (iclblasHandle_t handle, iclblasFillMode_t uplo, iclblasOperation_t trans, iclblasDiagType_t diag, int n, oclComplex_t AP, oclComplex_t x, int incx)
	Solves packed triangular linear system with single right-hand side. More...

iclblasStatus_t	iclblasChbmv (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, int k, const oclComplex_t alpha, oclComplex_t A, int lda, oclComplex_t x, int incx, const oclComplex_t beta, oclComplex_t *y, int incy)
	Performs Hermitian banded matrix by vector multiplication. More...

iclblasStatus_t	iclblasCsyr (iclblasHandle_t handle, iclblasFillMode_t uplo, int n, const oclComplex_t alpha, oclComplex_t x, int incx, oclComplex_t *A, int lda)
	Performs symmetrix matrix rank 1 update. More...

Detailed Description

Function Documentation

◆ iclblasCgbmv()

iclblasStatus_t iclblasCgbmv	(	iclblasHandle_t	handle,
		iclblasOperation_t	trans,
		int	m,
		int	n,
		int	kl,
		int	ku,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx,
		const oclComplex_t *	beta,
		oclComplex_t *	y,
		int	incy
	)

Performs general banded matrix by vector multiplication.

y = alpha * op(A) * x + beta * y

Where alpha and beta are scalars, x and y are vectors, A is m by n banded matrix with kl subdiagonals and ku superdiagonals, and op(A) is indicated by value of trans as follows:

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

Matrix A is stored coulumn by column with element A(i, j) at location A(ku + i - j, j) in memory. The elements that do not correspond to elements in banded matrix (top left ku x ku and bottom right kl x kl triangles) are not referenced.

Parameters

[in]	handle	handle to the library context
[in]	trans	indicates operation used for multiplication
[in]	m	number of rows in matrix A; should be at least 0
[in]	n	number of columns in matrix A; should be at least 0
[in]	kl	number of subdiagonals in matrix A; should be at least 0
[in]	ku	number of superdiagonals in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least kl + ku + 1
[in]	x	vector of size at least n * incx if `trans == ICLBLAS_OP_N` and m * incx otherwise
[in]	incx	stride between elements in x; should be at least 1
[in]	beta	scalar used for multiplication; if `beta == 0`, y does not have to be initialized
[in,out]	y	vector of size at least m * incy if `trans == ICLBLAS_OP_N` and n * incy otherwise
[in]	incy	stride between elements of y; should be at least 1

◆ iclblasCgemv()

iclblasStatus_t iclblasCgemv	(	iclblasHandle_t	handle,
		iclblasOperation_t	trans,
		int	m,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx,
		const oclComplex_t *	beta,
		oclComplex_t *	y,
		int	incy
	)

Performs general matrix by vector multiplication.

y = alpha * op(A) * x + beta * y

Where alpha and beta are scalars, x and y are vectors, A is m by n matrix, and op(A) is indicated by value of trans as follows:

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

Parameters

[in]	handle	handle to the library context
[in]	trans	indicates operation used in multiplication
[in]	m	number of rows of matrix A; should be at least 0
[in]	n	number of columns of matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	A	array of size at least [lda x n] storing matrix A
[in]	lda	leading dimension of array A; should be at least max(1, m)
[in]	x	vector of size at least n * incx if `trans == ICLBLAS_OP_N` and m * incx otherwise
[in]	incx	stride between elements in x; should be at least 1
[in]	beta	scalar used in multiplication; if `beta == 0`, y does not have to be initialized
[in,out]	y	vector of size at least m * incy if `trans == ICLBLAS_OP_N` and n * incy otherwise
[in]	incy	stride between elements of y; should be at least 1

◆ iclblasCgerc()

iclblasStatus_t iclblasCgerc	(	iclblasHandle_t	handle,
		int	m,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	x,
		int	incx,
		oclComplex_t *	y,
		int	incy,
		oclComplex_t *	A,
		int	lda
	)

Performs general matrix rank 1 update.

A = alpha * x * y ^ H + A

Where alpha is scalar, x is m element vector, y is n elements vector, and A is m by n matrix.

Parameters

[in]	handle	handle to the library context
[in]	m	number of rows in matrix A; should be at least 0
[in]	n	number of columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	x	vector of size at least m * incx
[in]	incx	stride between elements in x; should be at least 1
[in]	y	vector of size at least n * incy
[in]	incy	stride between elements in y; should be at least 1
[in,out]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least max(1, m)

◆ iclblasCgeru()

iclblasStatus_t iclblasCgeru	(	iclblasHandle_t	handle,
		int	m,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	x,
		int	incx,
		oclComplex_t *	y,
		int	incy,
		oclComplex_t *	A,
		int	lda
	)

Performs general matrix rank 1 update.

A = alpha * x * y ^ T + A

Where alpha is scalar, x is m element vector, y is n elements vector, and A is m by n matrix.

Parameters

[in]	handle	handle to the library context
[in]	m	number of rows in matrix A; should be at least 0
[in]	n	number of columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	x	vector of size at least m * incx
[in]	incx	stride between elements in x; should be at least 1
[in]	y	vector of size at least n * incy
[in]	incy	stride between elements in y; should be at least 1
[in,out]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least max(1, m)

◆ iclblasChbmv()

iclblasStatus_t iclblasChbmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		int	k,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx,
		const oclComplex_t *	beta,
		oclComplex_t *	y,
		int	incy
	)

Performs Hermitian banded matrix by vector multiplication.

y = alpha * A * x + beta * y

Where alpha and beta are scalars, x and y are n element vectors, A is n by n Hermitian banded matrix with k subdiagonals and superdiagonals.

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is stored column by column with element A(i, j) at location A(k + i - j, j) in memory. The elements that don't correspond to elements in banded matrix (the top left k x k triangle) are not referenced.

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is stored column by column with element A(i, j) at location A(i - j, j) in memory. The elements that don't correspond to elements in banded matrix (the bottom right k x k triangle) are not referenced.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower part of matrix is stored in A
[in]	n	number of rows and columns of A; should be at least 0
[in]	k	number of sub- and super-diagonals of matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least k + 1
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements of x; should be at least 1
[in]	beta	scalar used in multiplication; if `beta == 0`, y does not have to be initialized
[in,out]	y	vector of size at least n * incy
[in]	incy	stride between elements of y; should be at least 1

◆ iclblasChemv()

iclblasStatus_t iclblasChemv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx,
		const oclComplex_t *	beta,
		oclComplex_t *	y,
		int	incy
	)

Performs Hermitian matrix by vector multiplication.

y = alpha * A * x + beta * y

Where alpha and beta are scalars, x and y are n element vectors, and A is n by n Hermitian matrix stored in upper or lower mode.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower part of matrix is stored in A
[in]	n	number of rows and columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least max(1, n)
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements in x; should be at least 1
[in]	beta	scalar used in multiplication; if `beta == 0` then y does not have to be initialized
[in,out]	y	vector of size at least n * incy
[in]	incy	stride between elements in y; should be at least 1

◆ iclblasCher()

iclblasStatus_t iclblasCher	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const float *	alpha,
		oclComplex_t *	x,
		int	incx,
		oclComplex_t *	A,
		int	lda
	)

Performs Hermitian matrix rank 1 update.

A = alpha * x * x ^ H + A

Where alpha is scalar, x is n element vector, and A is n by n Hermitian matrix stored in upper or lower mode.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower part of matrix is stored in A
[in]	n	number of rows and columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements in x; should be at least 1
[in,out]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least max(1, n)

◆ iclblasCher2()

iclblasStatus_t iclblasCher2	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	x,
		int	incx,
		oclComplex_t *	y,
		int	incy,
		oclComplex_t *	A,
		int	lda
	)

Performs Hermitian matrix rank 2 update.

A = alpha * x * y ^ H + conj(alpha) * y * x ^ H + A

Where alpha is scalar, x and y are n element vectors, and A is n by n Hermitian matrix stored in upper or lower mode.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower part of matrix is stored in A
[in]	n	number of rows and columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements in x; should be at least 1
[in]	y	vector of size at least n * incy
[in]	incy	stride between elements in y; should be at least 1
[in,out]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least max(1, n)

◆ iclblasChpmv()

iclblasStatus_t iclblasChpmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	AP,
		oclComplex_t *	x,
		int	incx,
		const oclComplex_t *	beta,
		oclComplex_t *	y,
		int	incy
	)

Performs packed Hermitian matrix by vector multiplication.

y = alpha * A * x + beta * y

Where alpha and beta are scalars, x and y are n element vectors, A is n by n Hermitian matrix in upper or lower mode, stored in packed format.

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(j + 1) * j / 2 + i].

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(2 * n - j - 1) * j / 2 + i].

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower part of matrix is stored in AP
[in]	n	number of rows and columns in A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	AP	array of size at least n * (n + 1) / 2 containing matrix A stored in packed format
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements of x; should be at least 1
[in]	beta	scalar used in multiplication; if `beta == 0` then y does not have to be initialized
[in,out]	y	vector of size at least n * incy
[in]	incy	stride between elements of y; should be at least 1

◆ iclblasChpr()

iclblasStatus_t iclblasChpr	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const float *	alpha,
		oclComplex_t *	x,
		int	incx,
		oclComplex_t *	AP
	)

Performs packed Hermitian matrix rank 1 update.

A = alpha * x * x ^ H + A

Where alpha is scalar, x is n element vector, and A is n by n Hermitian matrix in upper or lower mode, stored in packed format.

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(j + 1) * j / 2 + i].

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(2 * n - j - 1) * j / 2 + i].

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower triangle is stored in AP
[in]	n	number of rows and columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements in x; should be at least 1
[in,out]	AP	array of size at least n * (n + 1) / 2 containing matrix A stored in packed format

◆ iclblasChpr2()

iclblasStatus_t iclblasChpr2	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	x,
		int	incx,
		oclComplex_t *	y,
		int	incy,
		oclComplex_t *	AP
	)

Performs packed Hermitian matrix rank 2 update.

A = alpha * x * y ^ H + conj(alpha) * y * x ^ H + A

Where alpha is scalar, x and y are n element vectors, and A is n by n Hermitian matrix in upper or lower mode, stored in packed format.

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(j + 1) * j / 2 + i].

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(2 * n - j - 1) * j / 2 + i].

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower part of matrix is stored in AP
[in]	n	number of rows and columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements in x; should be at least 1
[in]	y	vector of size at least n * incy
[in]	incy	stride between elements in y; should be at least 1
[in,out]	AP	array of size at least n * (n + 1) / 2 containing matrix A stored in packed format

◆ iclblasCsyr()

iclblasStatus_t iclblasCsyr	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const oclComplex_t *	alpha,
		oclComplex_t *	x,
		int	incx,
		oclComplex_t *	A,
		int	lda
	)

Performs symmetrix matrix rank 1 update.

A = alpha * x * x ^ T + A

Where alpha is scalar, x is n element vector and A is n by n symmetric matrix, stored in upper or lower mode.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if upper or lower part of matrix is stored in A
[in]	n	number of rows and columns in matrix A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	x	vector of size at least n * incx
[in]	incx	stride between elements in x; should be at least 1
[in,out]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least max(1, n)

◆ iclblasCtbmv()

iclblasStatus_t iclblasCtbmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		int	k,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx
	)

Performs triangular banded matrix by vector multiplication.

x = op(A) * x

Where x is n element vector, A is n by n, upper or lower, unit or non-unit triangular banded matrix with k sub- or super-diagonals, and op(A) is indicated by value of trans as follows:

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

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is stored column by column with element A(i, j) at location A(k + i - j, j) in memory. The elements that don't correspond to elements in banded matrix (the top left k x k triangle) are not referenced.

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is stored column by column with element A(i, j) at location A(i - j, j) in memory. The elements that don't correspond to elements in banded matrix (the bottom right k x k triangle) are not referenced.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if A is upper or lower triangular
[in]	trans	indicates operation used for multiplication
[in]	diag	indicates if A is unit or non-unit triangular
[in]	n	number of rows and columns in A; should be at least 0
[in]	k	number of sub- or super-diagonals of matrix A; should be at least 0
[in]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least k + 1
[in,out]	x	vector of size at least n * incx
[in]	incx	stride between elements of x; should be at least 1

◆ iclblasCtbsv()

iclblasStatus_t iclblasCtbsv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		int	k,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx
	)

Solves triangular banded linear system with single right-hand side.

op(A) * x = b

Where b and x are n element vectors and A is n by n, unit or non-unit, upper or lower triangular banded matrix with k sub- or super-diagonals.

Operation on matrix A when solving is specified by value of trans as follows:

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

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is stored column by column with element A(i, j) at location A(k + i - j, j) in memory. The elements that don't correspond to elements in banded matrix (the top left k x k triangle) are not referenced.

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is stored column by column with element A(i, j) at location A(i - j, j) in memory. The elements that don't correspond to elements in banded matrix (the bottom right k x k triangle) are not referenced.

On exit solution x overwrites right-hand side vector b.

No test for singularity or near-singularity is included in this routine.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if matrix A is an upper or lower triangular
[in]	trans	indicates equation to be solved as operation on A
[in]	diag	indicates if matrix A is unit or non-unit triangular
[in]	n	specifies order of matrix A; should be at least 0
[in]	k	number of sub- or super-diagonals of matrix A; should be at least 0
[in]	A	array of size [lda x n] storing matrix A
[in]	lda	first dimension of A; should be at least k + 1
[in,out]	x	array of size at least n * incx; on entry stores vector b, overwritten by vector x on exit
[in]	incx	stride between elements in x; should be at least 1

◆ iclblasCtpmv()

iclblasStatus_t iclblasCtpmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		oclComplex_t *	AP,
		oclComplex_t *	x,
		int	incx
	)

Performs packed triangular matrix by vector multiplication.

x = op(A) * x

Where x is n element vector, A is n by n, unit or non-unit, upper or lower triangular matrix stored in packed format, and op(A) is indicated by value of trans as follows:

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

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(j + 1) * j / 2 + i].

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(2 * n - j - 1) * j / 2 + i].

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if A is upper or lower triangular
[in]	trans	indicates operation used for multiplication
[in]	diag	indicates if A is unit or non-unit triangular
[in]	n	number of rows and columns of matrix A; should be at least 0
[in]	AP	array of size at least n * (n + 1) / 2 containing matrix A stored in packed format
[in,out]	x	vector of size at least n * incx
[in]	incx	stride between elements of x; should be at least 1

◆ iclblasCtpsv()

iclblasStatus_t iclblasCtpsv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		oclComplex_t *	AP,
		oclComplex_t *	x,
		int	incx
	)

Solves packed triangular linear system with single right-hand side.

op(A) * x = b

Where b and x are n element vectors and A is n by n, unit or non-unit, upper or lower triangular matrix stored in packed format.

Equation to be solved is specified by value of trans as operation on A.

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

If uplo == ICLBLAS_FILL_MODE_UPPER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(j + 1) * j / 2 + i].

If uplo == ICLBLAS_FILL_MODE_LOWER then the matrix A is packed column by column with element A(i, j) stored in memory at location AP[(2 * n - j - 1) * j / 2 + i].

On exit solution x overwrites right-hand side vector b.

No test for singularity or near-singularity is included in this routine.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if matrix A is an upper or lower triangular
[in]	trans	indicates equation to be solved as operation on A
[in]	diag	indicates if matrix A is unit or non-unit triangular
[in]	n	specifies order of matrix A; should be at least 0
[in]	AP	array of size at least n * (n + 1) / 2 containing matrix A stored in packed format
[in,out]	x	array of size at least n * incx; on entry stores vector b, overwritten by vector x on exit
[in]	incx	stride between elements in x; should be at least 1

◆ iclblasCtrmv()

iclblasStatus_t iclblasCtrmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx
	)

Performs triangular matrix by vector multiplication.

x = op(A) * x

Where x is n element vector, A is n by n, upper or lower, unit or non-unit triangular matrix, and op(A) is indicated by value of trans as follows:

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

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if A is upper or lower triangular
[in]	trans	indicates operation used for multiplication
[in]	diag	indicates if A is unit or non-unit triangular
[in]	n	number of rows and columns in A; should be at least 0
[in]	A	array of size [lda x n] storing matrix A
[in]	lda	leading dimension of A; should be at least max(1, n)
[in,out]	x	vector of size at least n * incx
[in]	incx	stride between elements of x; should be at least 1

◆ iclblasCtrsv()

iclblasStatus_t iclblasCtrsv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		oclComplex_t *	A,
		int	lda,
		oclComplex_t *	x,
		int	incx
	)

Solves triangular linear system with single right-hand side.

op(A) * x = b

Where b and x are n element vectors and A is n by n, unit or non-unit, upper or lower triangular matrix.

Equation to be solved is specified by value of trans as follows:

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

On exit solution x overwrites right-hand side vector b.

No test for singularity or near-singularity is included in this routine.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if matrix A is an upper or lower triangular
[in]	trans	indicates equation to be solved as operation on A
[in]	diag	indicates if matrix A is unit or non-unit triangular
[in]	n	specifies order of matrix A; should be at least 0
[in]	A	array of size [lda x n] storing matrix A
[in]	lda	first dimension of A; should be at least max(1, n)
[in,out]	x	array of size at least n * incx; on entry stores vector b, overwritten by vector x on exit
[in]	incx	stride between elements in x; should be at least 1

Functions

Detailed Description

Function Documentation

◆ iclblasCgbmv()

◆ iclblasCgemv()

◆ iclblasCgerc()

◆ iclblasCgeru()

◆ iclblasChbmv()

◆ iclblasChemv()

◆ iclblasCher()

◆ iclblasCher2()

◆ iclblasChpmv()

◆ iclblasChpr()

◆ iclblasChpr2()

◆ iclblasCsyr()

◆ iclblasCtbmv()

◆ iclblasCtbsv()

◆ iclblasCtpmv()

◆ iclblasCtpsv()

◆ iclblasCtrmv()

◆ iclblasCtrsv()