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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Detailed Description

Function Documentation

◆ iclblasSgbmv()

iclblasStatus_t iclblasSgbmv	(	iclblasHandle_t	handle,
		iclblasOperation_t	trans,
		int	m,
		int	n,
		int	kl,
		int	ku,
		const float *	alpha,
		float *	A,
		int	lda,
		float *	x,
		int	incx,
		const float *	beta,
		float *	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 ^ T

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]
[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

◆ iclblasSgemv()

iclblasStatus_t iclblasSgemv	(	iclblasHandle_t	handle,
		iclblasOperation_t	trans,
		int	m,
		int	n,
		const float *	alpha,
		float *	A,
		int	lda,
		float *	x,
		int	incx,
		const float *	beta,
		float *	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 ^ T

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

◆ iclblasSger()

iclblasStatus_t iclblasSger	(	iclblasHandle_t	handle,
		int	m,
		int	n,
		const float *	alpha,
		float *	x,
		int	incx,
		float *	y,
		int	incy,
		float *	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)

◆ iclblasSsbmv()

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

Performs symmetric 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 symmetric 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

◆ iclblasSspmv()

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

Performs packed symmetric 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 symmetric matrix 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 of matrix 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`, 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

◆ iclblasSspr()

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

Performs packed symmetric matrix rank 1 update.

A = alpha * x * x ^ T + A

Where alpha is a scalar, x is n element vector and A is n by n symmetric matrix 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]	x	vector of size at least n * incx
[in]	incx	stride between elements of 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

◆ iclblasSspr2()

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

Performs packed symmetric matrix rank 2 update.

A = alpha * ( x * y ^ T + y * x ^ T ) + A

Where alpha is a scalar, x and y are n element vectors and A is n by n symmetric matrix 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]	x	vector of size at least n * incx
[in]	incx	stride between elements of x; should be at least 1
[in]	y	vector of size at least n * incy
[in]	incy	stride between elements of 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

◆ iclblasSsymv()

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

Performs symmetric 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 the n x n symmetric matrix in lower or upper mode.

Parameters

[in]	handle	handle to the library context
[in]	uplo	indicates if lower or upper part of matrix is stored in A
[in]	n	number of rows and columns in A; should be at least 0
[in]	alpha	scalar used in multiplication
[in]	A	array of size [lda x n]
[in]	lda	first dimension of A; must 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`, 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

◆ iclblasSsyr()

iclblasStatus_t iclblasSsyr	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		int	n,
		const float *	alpha,
		float *	x,
		int	incx,
		float *	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)

◆ iclblasSsyr2()

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

Performs symmetrix matrix rank 2 update.

A = alpha * ( x * y ^ T + y * x ^ T ) + A

Where alpha is scalar, x and y are n element vectors, 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]	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)

◆ iclblasStbmv()

iclblasStatus_t iclblasStbmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		int	k,
		float *	A,
		int	lda,
		float *	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 ^ T

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

◆ iclblasStbsv()

iclblasStatus_t iclblasStbsv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		int	k,
		float *	A,
		int	lda,
		float *	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 ^ T

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

◆ iclblasStpmv()

iclblasStatus_t iclblasStpmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		float *	AP,
		float *	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 ^ T

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

◆ iclblasStpsv()

iclblasStatus_t iclblasStpsv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		float *	AP,
		float *	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 ^ T

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

◆ iclblasStrmv()

iclblasStatus_t iclblasStrmv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		float *	A,
		int	lda,
		float *	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 ^ T

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

◆ iclblasStrsv()

iclblasStatus_t iclblasStrsv	(	iclblasHandle_t	handle,
		iclblasFillMode_t	uplo,
		iclblasOperation_t	trans,
		iclblasDiagType_t	diag,
		int	n,
		float *	A,
		int	lda,
		float *	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 ^ T

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

◆ iclblasSgbmv()

◆ iclblasSgemv()

◆ iclblasSger()

◆ iclblasSsbmv()

◆ iclblasSspmv()

◆ iclblasSspr()

◆ iclblasSspr2()

◆ iclblasSsymv()

◆ iclblasSsyr()

◆ iclblasSsyr2()

◆ iclblasStbmv()

◆ iclblasStbsv()

◆ iclblasStpmv()

◆ iclblasStpsv()

◆ iclblasStrmv()

◆ iclblasStrsv()