Functions
magma_int_t	magma_ccustomspmv (magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex beta, magmaFloatComplex x, magmaFloatComplex y, magma_queue_t queue)
	This is an interface to any custom sparse matrix vector product.

magma_int_t	magma_cge3pt (magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex beta, magmaFloatComplex_ptr dx, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine is a 3-pt-stencil operator derived from a FD-scheme in 2D with Dirichlet boundary.

magma_int_t	magma_cgecsrmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr drowptr, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes y = alpha * A * x + beta * y on the GPU.

magma_int_t	magma_cgecsrmv_shift (magma_trans_t transA, magma_int_t m, magma_int_t n, magmaFloatComplex alpha, magmaFloatComplex lambda, magmaFloatComplex_ptr dval, magmaIndex_ptr drowptr, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magma_int_t offset, magma_int_t blocksize, magma_index_t *addrows, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes y = alpha * ( A -lambda I ) * x + beta * y on the GPU.

magma_int_t	magma_cgeellmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t nnz_per_row, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes y = alpha * A * x + beta * y on the GPU.

magma_int_t	magma_cgeellmv_shift (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t nnz_per_row, magmaFloatComplex alpha, magmaFloatComplex lambda, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magma_int_t offset, magma_int_t blocksize, magmaIndex_ptr addrows, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes y = alpha ( A - lambda I ) x + beta * y on the GPU.

magma_int_t	magma_cgeellrtmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t nnz_per_row, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaIndex_ptr drowlength, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_int_t alignment, magma_int_t blocksize, magma_queue_t queue)
	This routine computes y = alpha * A * x + beta * y on the GPU.

magma_int_t	magma_cgeelltmv_shift (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t nnz_per_row, magmaFloatComplex alpha, magmaFloatComplex lambda, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magma_int_t offset, magma_int_t blocksize, magmaIndex_ptr addrows, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes y = alpha ( A - lambda I ) x + beta * y on the GPU.

magma_int_t	magma_cmdotc (magma_int_t n, magma_int_t k, magmaFloatComplex_ptr v, magmaFloatComplex_ptr r, magmaFloatComplex_ptr d1, magmaFloatComplex_ptr d2, magmaFloatComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of vectors v_i such that.

magma_int_t	magma_cgesellpmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t blocksize, magma_int_t slices, magma_int_t alignment, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaIndex_ptr drowptr, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes y = alpha * A^t * x + beta * y on the GPU.

magma_int_t	magma_cgesellcmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t blocksize, magma_int_t slices, magma_int_t alignment, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaIndex_ptr drowptr, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes y = alpha * A^t * x + beta * y on the GPU.

magma_int_t	magma_cmdotc_shfl (magma_int_t n, magma_int_t k, magmaFloatComplex_ptr v, magmaFloatComplex_ptr r, magmaFloatComplex_ptr d1, magmaFloatComplex_ptr d2, magmaFloatComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of vectors v_i such that.

magma_int_t	magma_cmdotc1 (magma_int_t n, magmaFloatComplex_ptr v0, magmaFloatComplex_ptr w0, magmaFloatComplex_ptr d1, magmaFloatComplex_ptr d2, magmaFloatComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 1 vectors such that.

magma_int_t	magma_cmdotc2 (magma_int_t n, magmaFloatComplex_ptr v0, magmaFloatComplex_ptr w0, magmaFloatComplex_ptr v1, magmaFloatComplex_ptr w1, magmaFloatComplex_ptr d1, magmaFloatComplex_ptr d2, magmaFloatComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 2 vectors such that.

magma_int_t	magma_cmdotc3 (magma_int_t n, magmaFloatComplex_ptr v0, magmaFloatComplex_ptr w0, magmaFloatComplex_ptr v1, magmaFloatComplex_ptr w1, magmaFloatComplex_ptr v2, magmaFloatComplex_ptr w2, magmaFloatComplex_ptr d1, magmaFloatComplex_ptr d2, magmaFloatComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 4 vectors such that.

magma_int_t	magma_cmdotc4 (magma_int_t n, magmaFloatComplex_ptr v0, magmaFloatComplex_ptr w0, magmaFloatComplex_ptr v1, magmaFloatComplex_ptr w1, magmaFloatComplex_ptr v2, magmaFloatComplex_ptr w2, magmaFloatComplex_ptr v3, magmaFloatComplex_ptr w3, magmaFloatComplex_ptr d1, magmaFloatComplex_ptr d2, magmaFloatComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 4 vectors such that.

magma_int_t	magma_cmgecsrmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t num_vecs, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr drowptr, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes Y = alpha * A * X + beta * Y for X and Y sets of num_vec vectors on the GPU.

magma_int_t	magma_cmgeellmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t num_vecs, magma_int_t nnz_per_row, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes Y = alpha * A * X + beta * Y for X and Y sets of num_vec vectors on the GPU.

magma_int_t	magma_cmgeelltmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t num_vecs, magma_int_t nnz_per_row, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes Y = alpha * A * X + beta * Y for X and Y sets of num_vec vectors on the GPU.

magma_int_t	magma_cmgesellpmv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t num_vecs, magma_int_t blocksize, magma_int_t slices, magma_int_t alignment, magmaFloatComplex alpha, magmaFloatComplex_ptr dval, magmaIndex_ptr dcolind, magmaIndex_ptr drowptr, magmaFloatComplex_ptr dx, magmaFloatComplex beta, magmaFloatComplex_ptr dy, magma_queue_t queue)
	This routine computes Y = alpha * A^t * X + beta * Y on the GPU.

magma_int_t	magma_dmdotc1 (magma_int_t n, magmaDouble_ptr v0, magmaDouble_ptr w0, magmaDouble_ptr d1, magmaDouble_ptr d2, magmaDouble_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 1 vectors such that.

magma_int_t	magma_dmdotc2 (magma_int_t n, magmaDouble_ptr v0, magmaDouble_ptr w0, magmaDouble_ptr v1, magmaDouble_ptr w1, magmaDouble_ptr d1, magmaDouble_ptr d2, magmaDouble_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 2 vectors such that.

magma_int_t	magma_dmdotc3 (magma_int_t n, magmaDouble_ptr v0, magmaDouble_ptr w0, magmaDouble_ptr v1, magmaDouble_ptr w1, magmaDouble_ptr v2, magmaDouble_ptr w2, magmaDouble_ptr d1, magmaDouble_ptr d2, magmaDouble_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 4 vectors such that.

magma_int_t	magma_c_spmv (magmaFloatComplex alpha, magma_c_matrix A, magma_c_matrix x, magmaFloatComplex beta, magma_c_matrix y, magma_queue_t queue)
	For a given input matrix A and vectors x, y and scalars alpha, beta the wrapper determines the suitable SpMV computing y = alpha * A * x + beta * y.

magma_int_t	magma_c_spmv_shift (magmaFloatComplex alpha, magma_c_matrix A, magmaFloatComplex lambda, magma_c_matrix x, magmaFloatComplex beta, magma_int_t offset, magma_int_t blocksize, magma_index_t *add_rows, magma_c_matrix y, magma_queue_t queue)
	For a given input matrix A and vectors x, y and scalars alpha, beta the wrapper determines the suitable SpMV computing y = alpha * ( A - lambda I ) * x + beta * y.

magma_int_t	magma_c_spmm (magmaFloatComplex alpha, magma_c_matrix A, magma_c_matrix B, magma_c_matrix *C, magma_queue_t queue)
	For a given input matrix A and B and scalar alpha, the wrapper determines the suitable SpMV computing C = alpha * A * B.

magma_int_t	magma_ccuspaxpy (magmaFloatComplex alpha, magma_c_matrix A, magmaFloatComplex beta, magma_c_matrix B, magma_c_matrix *AB, magma_queue_t queue)
	This is an interface to the cuSPARSE routine csrgeam computing the sum of two sparse matrices stored in csr format:

magma_int_t	magma_ccuspmm (magma_c_matrix A, magma_c_matrix B, magma_c_matrix *AB, magma_queue_t queue)
	This is an interface to the cuSPARSE routine csrmm computing the product of two sparse matrices stored in csr format.

magma_int_t	magma_smdotc1 (magma_int_t n, magmaFloat_ptr v0, magmaFloat_ptr w0, magmaFloat_ptr d1, magmaFloat_ptr d2, magmaFloat_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 1 vectors such that.

magma_int_t	magma_smdotc2 (magma_int_t n, magmaFloat_ptr v0, magmaFloat_ptr w0, magmaFloat_ptr v1, magmaFloat_ptr w1, magmaFloat_ptr d1, magmaFloat_ptr d2, magmaFloat_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 2 vectors such that.

magma_int_t	magma_smdotc3 (magma_int_t n, magmaFloat_ptr v0, magmaFloat_ptr w0, magmaFloat_ptr v1, magmaFloat_ptr w1, magmaFloat_ptr v2, magmaFloat_ptr w2, magmaFloat_ptr d1, magmaFloat_ptr d2, magmaFloat_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 4 vectors such that.

magma_int_t	magma_zmdotc1 (magma_int_t n, magmaDoubleComplex_ptr v0, magmaDoubleComplex_ptr w0, magmaDoubleComplex_ptr d1, magmaDoubleComplex_ptr d2, magmaDoubleComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 1 vectors such that.

magma_int_t	magma_zmdotc2 (magma_int_t n, magmaDoubleComplex_ptr v0, magmaDoubleComplex_ptr w0, magmaDoubleComplex_ptr v1, magmaDoubleComplex_ptr w1, magmaDoubleComplex_ptr d1, magmaDoubleComplex_ptr d2, magmaDoubleComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 2 vectors such that.

magma_int_t	magma_zmdotc3 (magma_int_t n, magmaDoubleComplex_ptr v0, magmaDoubleComplex_ptr w0, magmaDoubleComplex_ptr v1, magmaDoubleComplex_ptr w1, magmaDoubleComplex_ptr v2, magmaDoubleComplex_ptr w2, magmaDoubleComplex_ptr d1, magmaDoubleComplex_ptr d2, magmaDoubleComplex_ptr skp, magma_queue_t queue)
	Computes the scalar product of a set of 4 vectors such that.

Detailed Description

Function Documentation

◆ magma_ccustomspmv()

magma_int_t magma_ccustomspmv	(	magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex	alpha,
		magmaFloatComplex	beta,
		magmaFloatComplex *	x,
		magmaFloatComplex *	y,
		magma_queue_t	queue )

This is an interface to any custom sparse matrix vector product.

It should compute y = alpha*FUNCTION(x) + beta*y The vectors are located on the device, the scalars on the CPU.

Parameters

[in]	m	magma_int_t number of rows
[in]	n	magma_int_t number of columns
[in]	alpha	magmaFloatComplex scalar alpha
[in]	x	magmaFloatComplex * input vector x
[in]	beta	magmaFloatComplex scalar beta
[out]	y	magmaFloatComplex * output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cge3pt()

magma_int_t magma_cge3pt	(	magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex	alpha,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine is a 3-pt-stencil operator derived from a FD-scheme in 2D with Dirichlet boundary.

It computes y_i = -2 x_i + x_{i-1} + x_{i+1}

Parameters

[in]	m	magma_int_t number of rows in x and y
[in]	n	magma_int_t number of columns in x and y
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	beta	magmaFloatComplex scalar multiplier
[in]	dx	magmaFloatComplex_ptr input vector x
[out]	dy	magmaFloatComplex_ptr output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgecsrmv()

magma_int_t magma_cgecsrmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	drowptr,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha * A * x + beta * y on the GPU.

The input format is CSR (val, row, col).

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in CSR
[in]	drowptr	magmaIndex_ptr rowpointer of A in CSR
[in]	dcolind	magmaIndex_ptr columnindices of A in CSR
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgecsrmv_shift()

magma_int_t magma_cgecsrmv_shift	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex	alpha,
		magmaFloatComplex	lambda,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	drowptr,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magma_int_t	offset,
		magma_int_t	blocksize,
		magma_index_t *	addrows,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha * ( A -lambda I ) * x + beta * y on the GPU.

It is a shifted version of the CSR-SpMV.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	lambda	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in CSR
[in]	drowptr	magmaIndex_ptr rowpointer of A in CSR
[in]	dcolind	magmaIndex_ptr columnindices of A in CSR
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[in]	offset	magma_int_t in case not the main diagonal is scaled
[in]	blocksize	magma_int_t in case of processing multiple vectors
[in]	addrows	magmaIndex_ptr in case the matrixpowerskernel is used
[out]	dy	magmaFloatComplex_ptr output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgeellmv()

magma_int_t magma_cgeellmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nnz_per_row,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha * A * x + beta * y on the GPU.

Input format is ELLPACK.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	nnz_per_row	magma_int_t number of elements in the longest row
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in ELLPACK
[in]	dcolind	magmaIndex_ptr columnindices of A in ELLPACK
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgeellmv_shift()

magma_int_t magma_cgeellmv_shift	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nnz_per_row,
		magmaFloatComplex	alpha,
		magmaFloatComplex	lambda,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magma_int_t	offset,
		magma_int_t	blocksize,
		magmaIndex_ptr	addrows,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha *( A - lambda I ) * x + beta * y on the GPU.

Input format is ELLPACK. It is the shifted version of the ELLPACK SpMV.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	nnz_per_row	magma_int_t number of elements in the longest row
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	lambda	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in ELLPACK
[in]	dcolind	magmaIndex_ptr columnindices of A in ELLPACK
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[in]	offset	magma_int_t in case not the main diagonal is scaled
[in]	blocksize	magma_int_t in case of processing multiple vectors
[in]	addrows	magmaIndex_ptr in case the matrixpowerskernel is used
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgeellrtmv()

magma_int_t magma_cgeellrtmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nnz_per_row,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaIndex_ptr	drowlength,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_int_t	alignment,
		magma_int_t	blocksize,
		magma_queue_t	queue )

This routine computes y = alpha * A * x + beta * y on the GPU.

Input format is ELLRT. The ideas are taken from "Improving the performance of the sparse matrix vector product with GPUs", (CIT 2010), and modified to provide correct values.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows
[in]	n	magma_int_t number of columns
[in]	nnz_per_row	magma_int_t max number of nonzeros in a row
[in]	alpha	magmaFloatComplex scalar alpha
[in]	dval	magmaFloatComplex_ptr val array
[in]	dcolind	magmaIndex_ptr col indices
[in]	drowlength	magmaIndex_ptr number of elements in each row
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar beta
[out]	dy	magmaFloatComplex_ptr output vector y
[in]	blocksize	magma_int_t threads per block
[in]	alignment	magma_int_t threads assigned to each row
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgeelltmv_shift()

magma_int_t magma_cgeelltmv_shift	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	nnz_per_row,
		magmaFloatComplex	alpha,
		magmaFloatComplex	lambda,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magma_int_t	offset,
		magma_int_t	blocksize,
		magmaIndex_ptr	addrows,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha *( A - lambda I ) * x + beta * y on the GPU.

Input format is ELL.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	nnz_per_row	magma_int_t number of elements in the longest row
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	lambda	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in ELL
[in]	dcolind	magmaIndex_ptr columnindices of A in ELL
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[in]	offset	magma_int_t in case not the main diagonal is scaled
[in]	blocksize	magma_int_t in case of processing multiple vectors
[in]	addrows	magmaIndex_ptr in case the matrixpowerskernel is used
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmdotc()

magma_int_t magma_cmdotc	(	magma_int_t	n,
		magma_int_t	k,
		magmaFloatComplex_ptr	v,
		magmaFloatComplex_ptr	r,
		magmaFloatComplex_ptr	d1,
		magmaFloatComplex_ptr	d2,
		magmaFloatComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of vectors v_i such that.

skp = ( <v_0,r>, <v_1,r>, .. )

Returns the vector skp.

Parameters

[in]	n	int length of v_i and r
[in]	k	int

vectors v_i

Parameters

[in]	v	magmaFloatComplex_ptr v = (v_0 .. v_i.. v_k)
[in]	r	magmaFloatComplex_ptr r
[in]	d1	magmaFloatComplex_ptr workspace
[in]	d2	magmaFloatComplex_ptr workspace
[out]	skp	magmaFloatComplex_ptr vector[k] of scalar products (<v_i,r>...)
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgesellpmv()

magma_int_t magma_cgesellpmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	blocksize,
		magma_int_t	slices,
		magma_int_t	alignment,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaIndex_ptr	drowptr,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha * A^t * x + beta * y on the GPU.

Input format is SELLP.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	blocksize	magma_int_t number of rows in one ELL-slice
[in]	slices	magma_int_t number of slices in matrix
[in]	alignment	magma_int_t number of threads assigned to one row
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in SELLP
[in]	dcolind	magmaIndex_ptr columnindices of A in SELLP
[in]	drowptr	magmaIndex_ptr rowpointer of SELLP
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cgesellcmv()

magma_int_t magma_cgesellcmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	blocksize,
		magma_int_t	slices,
		magma_int_t	alignment,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaIndex_ptr	drowptr,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes y = alpha * A^t * x + beta * y on the GPU.

Input format is SELLC/SELLP.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	blocksize	magma_int_t number of rows in one ELL-slice
[in]	slices	magma_int_t number of slices in matrix
[in]	alignment	magma_int_t number of threads assigned to one row (=1)
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in SELLC/P
[in]	dcolind	magmaIndex_ptr columnindices of A in SELLC/P
[in]	drowptr	magmaIndex_ptr rowpointer of SELLP
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmdotc_shfl()

magma_int_t magma_cmdotc_shfl	(	magma_int_t	n,
		magma_int_t	k,
		magmaFloatComplex_ptr	v,
		magmaFloatComplex_ptr	r,
		magmaFloatComplex_ptr	d1,
		magmaFloatComplex_ptr	d2,
		magmaFloatComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of vectors v_i such that.

skp = ( <v_0,r>, <v_1,r>, .. )

Returns the vector skp.

Parameters

[in]	n	int length of v_i and r
[in]	k	int

vectors v_i

Parameters

[in]	v	magmaFloatComplex_ptr v = (v_0 .. v_i.. v_k)
[in]	r	magmaFloatComplex_ptr r
[in]	d1	magmaFloatComplex_ptr workspace
[in]	d2	magmaFloatComplex_ptr workspace
[out]	skp	magmaFloatComplex_ptr vector[k] of scalar products (<v_i,r>...)
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmdotc1()

magma_int_t magma_cmdotc1	(	magma_int_t	n,
		magmaFloatComplex_ptr	v0,
		magmaFloatComplex_ptr	w0,
		magmaFloatComplex_ptr	d1,
		magmaFloatComplex_ptr	d2,
		magmaFloatComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 1 vectors such that.

skp[0] = [ <v_0,w_0> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaFloatComplex_ptr input vector
[in]	w0	magmaFloatComplex_ptr input vector
[in]	d1	magmaFloatComplex_ptr workspace
[in]	d2	magmaFloatComplex_ptr workspace
[out]	skp	magmaFloatComplex_ptr vector[4] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmdotc2()

magma_int_t magma_cmdotc2	(	magma_int_t	n,
		magmaFloatComplex_ptr	v0,
		magmaFloatComplex_ptr	w0,
		magmaFloatComplex_ptr	v1,
		magmaFloatComplex_ptr	w1,
		magmaFloatComplex_ptr	d1,
		magmaFloatComplex_ptr	d2,
		magmaFloatComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 2 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaFloatComplex_ptr input vector
[in]	w0	magmaFloatComplex_ptr input vector
[in]	v1	magmaFloatComplex_ptr input vector
[in]	w1	magmaFloatComplex_ptr input vector
[in]	d1	magmaFloatComplex_ptr workspace
[in]	d2	magmaFloatComplex_ptr workspace
[out]	skp	magmaFloatComplex_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmdotc3()

magma_int_t magma_cmdotc3	(	magma_int_t	n,
		magmaFloatComplex_ptr	v0,
		magmaFloatComplex_ptr	w0,
		magmaFloatComplex_ptr	v1,
		magmaFloatComplex_ptr	w1,
		magmaFloatComplex_ptr	v2,
		magmaFloatComplex_ptr	w2,
		magmaFloatComplex_ptr	d1,
		magmaFloatComplex_ptr	d2,
		magmaFloatComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 4 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1>, <v_2,w_2>, <v3,w_3> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaFloatComplex_ptr input vector
[in]	w0	magmaFloatComplex_ptr input vector
[in]	v1	magmaFloatComplex_ptr input vector
[in]	w1	magmaFloatComplex_ptr input vector
[in]	v2	magmaFloatComplex_ptr input vector
[in]	w2	magmaFloatComplex_ptr input vector
[in]	d1	magmaFloatComplex_ptr workspace
[in]	d2	magmaFloatComplex_ptr workspace
[out]	skp	magmaFloatComplex_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmdotc4()

magma_int_t magma_cmdotc4	(	magma_int_t	n,
		magmaFloatComplex_ptr	v0,
		magmaFloatComplex_ptr	w0,
		magmaFloatComplex_ptr	v1,
		magmaFloatComplex_ptr	w1,
		magmaFloatComplex_ptr	v2,
		magmaFloatComplex_ptr	w2,
		magmaFloatComplex_ptr	v3,
		magmaFloatComplex_ptr	w3,
		magmaFloatComplex_ptr	d1,
		magmaFloatComplex_ptr	d2,
		magmaFloatComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 4 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1>, <v_2,w_2>, <v3,w_3> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaFloatComplex_ptr input vector
[in]	w0	magmaFloatComplex_ptr input vector
[in]	v1	magmaFloatComplex_ptr input vector
[in]	w1	magmaFloatComplex_ptr input vector
[in]	v2	magmaFloatComplex_ptr input vector
[in]	w2	magmaFloatComplex_ptr input vector
[in]	v3	magmaFloatComplex_ptr input vector
[in]	w3	magmaFloatComplex_ptr input vector
[in]	d1	magmaFloatComplex_ptr workspace
[in]	d2	magmaFloatComplex_ptr workspace
[out]	skp	magmaFloatComplex_ptr vector[4] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmgecsrmv()

magma_int_t magma_cmgecsrmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	num_vecs,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	drowptr,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes Y = alpha * A * X + beta * Y for X and Y sets of num_vec vectors on the GPU.

Input format is CSR.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	num_vecs	mama_int_t number of vectors
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in CSR
[in]	drowptr	magmaIndex_ptr rowpointer of A in CSR
[in]	dcolind	magmaIndex_ptr columnindices of A in CSR
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmgeellmv()

magma_int_t magma_cmgeellmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	num_vecs,
		magma_int_t	nnz_per_row,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes Y = alpha * A * X + beta * Y for X and Y sets of num_vec vectors on the GPU.

Input format is ELLPACK.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	num_vecs	mama_int_t number of vectors
[in]	nnz_per_row	magma_int_t number of elements in the longest row
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in ELLPACK
[in]	dcolind	magmaIndex_ptr columnindices of A in ELLPACK
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmgeelltmv()

magma_int_t magma_cmgeelltmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	num_vecs,
		magma_int_t	nnz_per_row,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes Y = alpha * A * X + beta * Y for X and Y sets of num_vec vectors on the GPU.

Input format is ELL.

Parameters

[in]	transA	magma_trans_t transposition parameter for A
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	num_vecs	mama_int_t number of vectors
[in]	nnz_per_row	magma_int_t number of elements in the longest row
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in ELL
[in]	dcolind	magmaIndex_ptr columnindices of A in ELL
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_cmgesellpmv()

magma_int_t magma_cmgesellpmv	(	magma_trans_t	transA,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	num_vecs,
		magma_int_t	blocksize,
		magma_int_t	slices,
		magma_int_t	alignment,
		magmaFloatComplex	alpha,
		magmaFloatComplex_ptr	dval,
		magmaIndex_ptr	dcolind,
		magmaIndex_ptr	drowptr,
		magmaFloatComplex_ptr	dx,
		magmaFloatComplex	beta,
		magmaFloatComplex_ptr	dy,
		magma_queue_t	queue )

This routine computes Y = alpha * A^t * X + beta * Y on the GPU.

Input format is SELLP. Note, that the input format for X is row-major while the output format for Y is column major!

Parameters

[in]	transA	magma_trans_t transpose A?
[in]	m	magma_int_t number of rows in A
[in]	n	magma_int_t number of columns in A
[in]	num_vecs	magma_int_t number of columns in X and Y
[in]	blocksize	magma_int_t number of rows in one ELL-slice
[in]	slices	magma_int_t number of slices in matrix
[in]	alignment	magma_int_t number of threads assigned to one row
[in]	alpha	magmaFloatComplex scalar multiplier
[in]	dval	magmaFloatComplex_ptr array containing values of A in SELLP
[in]	dcolind	magmaIndex_ptr columnindices of A in SELLP
[in]	drowptr	magmaIndex_ptr rowpointer of SELLP
[in]	dx	magmaFloatComplex_ptr input vector x
[in]	beta	magmaFloatComplex scalar multiplier
[out]	dy	magmaFloatComplex_ptr input/output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_dmdotc1()

magma_int_t magma_dmdotc1	(	magma_int_t	n,
		magmaDouble_ptr	v0,
		magmaDouble_ptr	w0,
		magmaDouble_ptr	d1,
		magmaDouble_ptr	d2,
		magmaDouble_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 1 vectors such that.

skp[0] = [ <v_0,w_0> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaDouble_ptr input vector
[in]	w0	magmaDouble_ptr input vector
[in]	d1	magmaDouble_ptr workspace
[in]	d2	magmaDouble_ptr workspace
[out]	skp	magmaDouble_ptr vector[4] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_dmdotc2()

magma_int_t magma_dmdotc2	(	magma_int_t	n,
		magmaDouble_ptr	v0,
		magmaDouble_ptr	w0,
		magmaDouble_ptr	v1,
		magmaDouble_ptr	w1,
		magmaDouble_ptr	d1,
		magmaDouble_ptr	d2,
		magmaDouble_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 2 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaDouble_ptr input vector
[in]	w0	magmaDouble_ptr input vector
[in]	v1	magmaDouble_ptr input vector
[in]	w1	magmaDouble_ptr input vector
[in]	d1	magmaDouble_ptr workspace
[in]	d2	magmaDouble_ptr workspace
[out]	skp	magmaDouble_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_dmdotc3()

magma_int_t magma_dmdotc3	(	magma_int_t	n,
		magmaDouble_ptr	v0,
		magmaDouble_ptr	w0,
		magmaDouble_ptr	v1,
		magmaDouble_ptr	w1,
		magmaDouble_ptr	v2,
		magmaDouble_ptr	w2,
		magmaDouble_ptr	d1,
		magmaDouble_ptr	d2,
		magmaDouble_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 4 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1>, <v_2,w_2>, <v3,w_3> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaDouble_ptr input vector
[in]	w0	magmaDouble_ptr input vector
[in]	v1	magmaDouble_ptr input vector
[in]	w1	magmaDouble_ptr input vector
[in]	v2	magmaDouble_ptr input vector
[in]	w2	magmaDouble_ptr input vector
[in]	d1	magmaDouble_ptr workspace
[in]	d2	magmaDouble_ptr workspace
[out]	skp	magmaDouble_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_c_spmv()

magma_int_t magma_c_spmv	(	magmaFloatComplex	alpha,
		magma_c_matrix	A,
		magma_c_matrix	x,
		magmaFloatComplex	beta,
		magma_c_matrix	y,
		magma_queue_t	queue )

For a given input matrix A and vectors x, y and scalars alpha, beta the wrapper determines the suitable SpMV computing y = alpha * A * x + beta * y.

Parameters

[in]	alpha	magmaFloatComplex scalar alpha
[in]	A	magma_c_matrix sparse matrix A
[in]	x	magma_c_matrix input vector x
[in]	beta	magmaFloatComplex scalar beta
[out]	y	magma_c_matrix output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_c_spmv_shift()

magma_int_t magma_c_spmv_shift	(	magmaFloatComplex	alpha,
		magma_c_matrix	A,
		magmaFloatComplex	lambda,
		magma_c_matrix	x,
		magmaFloatComplex	beta,
		magma_int_t	offset,
		magma_int_t	blocksize,
		magma_index_t *	add_rows,
		magma_c_matrix	y,
		magma_queue_t	queue )

For a given input matrix A and vectors x, y and scalars alpha, beta the wrapper determines the suitable SpMV computing y = alpha * ( A - lambda I ) * x + beta * y.

Parameters

	alpha	magmaFloatComplex scalar alpha
	A	magma_c_matrix sparse matrix A
	lambda	magmaFloatComplex scalar lambda
	x	magma_c_matrix input vector x
	beta	magmaFloatComplex scalar beta
	offset	magma_int_t in case not the main diagonal is scaled
	blocksize	magma_int_t in case of processing multiple vectors
	add_rows	magma_int_t* in case the matrixpowerskernel is used
	y	magma_c_matrix output vector y
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_c_spmm()

magma_int_t magma_c_spmm	(	magmaFloatComplex	alpha,
		magma_c_matrix	A,
		magma_c_matrix	B,
		magma_c_matrix *	C,
		magma_queue_t	queue )

For a given input matrix A and B and scalar alpha, the wrapper determines the suitable SpMV computing C = alpha * A * B.

Parameters

[in]	alpha	magmaFloatComplex scalar alpha
[in]	A	magma_c_matrix sparse matrix A
[in]	B	magma_c_matrix sparse matrix C
[out]	C	magma_c_matrix * outpur sparse matrix C
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_ccuspaxpy()

magma_int_t magma_ccuspaxpy	(	magmaFloatComplex *	alpha,
		magma_c_matrix	A,
		magmaFloatComplex *	beta,
		magma_c_matrix	B,
		magma_c_matrix *	AB,
		magma_queue_t	queue )

This is an interface to the cuSPARSE routine csrgeam computing the sum of two sparse matrices stored in csr format:

C = alpha * A + beta * B

Parameters

[in]	alpha	magmaFloatComplex* scalar
[in]	A	magma_c_matrix input matrix
[in]	beta	magmaFloatComplex* scalar
[in]	B	magma_c_matrix input matrix
[out]	AB	magma_c_matrix* output matrix AB = alpha * A + beta * B
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_ccuspmm()

magma_int_t magma_ccuspmm	(	magma_c_matrix	A,
		magma_c_matrix	B,
		magma_c_matrix *	AB,
		magma_queue_t	queue )

This is an interface to the cuSPARSE routine csrmm computing the product of two sparse matrices stored in csr format.

Parameters

[in]	A	magma_c_matrix input matrix
[in]	B	magma_c_matrix input matrix
[out]	AB	magma_c_matrix* output matrix AB = A * B
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_smdotc1()

magma_int_t magma_smdotc1	(	magma_int_t	n,
		magmaFloat_ptr	v0,
		magmaFloat_ptr	w0,
		magmaFloat_ptr	d1,
		magmaFloat_ptr	d2,
		magmaFloat_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 1 vectors such that.

skp[0] = [ <v_0,w_0> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaFloat_ptr input vector
[in]	w0	magmaFloat_ptr input vector
[in]	d1	magmaFloat_ptr workspace
[in]	d2	magmaFloat_ptr workspace
[out]	skp	magmaFloat_ptr vector[4] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_smdotc2()

magma_int_t magma_smdotc2	(	magma_int_t	n,
		magmaFloat_ptr	v0,
		magmaFloat_ptr	w0,
		magmaFloat_ptr	v1,
		magmaFloat_ptr	w1,
		magmaFloat_ptr	d1,
		magmaFloat_ptr	d2,
		magmaFloat_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 2 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaFloat_ptr input vector
[in]	w0	magmaFloat_ptr input vector
[in]	v1	magmaFloat_ptr input vector
[in]	w1	magmaFloat_ptr input vector
[in]	d1	magmaFloat_ptr workspace
[in]	d2	magmaFloat_ptr workspace
[out]	skp	magmaFloat_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_smdotc3()

magma_int_t magma_smdotc3	(	magma_int_t	n,
		magmaFloat_ptr	v0,
		magmaFloat_ptr	w0,
		magmaFloat_ptr	v1,
		magmaFloat_ptr	w1,
		magmaFloat_ptr	v2,
		magmaFloat_ptr	w2,
		magmaFloat_ptr	d1,
		magmaFloat_ptr	d2,
		magmaFloat_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 4 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1>, <v_2,w_2>, <v3,w_3> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaFloat_ptr input vector
[in]	w0	magmaFloat_ptr input vector
[in]	v1	magmaFloat_ptr input vector
[in]	w1	magmaFloat_ptr input vector
[in]	v2	magmaFloat_ptr input vector
[in]	w2	magmaFloat_ptr input vector
[in]	d1	magmaFloat_ptr workspace
[in]	d2	magmaFloat_ptr workspace
[out]	skp	magmaFloat_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_zmdotc1()

magma_int_t magma_zmdotc1	(	magma_int_t	n,
		magmaDoubleComplex_ptr	v0,
		magmaDoubleComplex_ptr	w0,
		magmaDoubleComplex_ptr	d1,
		magmaDoubleComplex_ptr	d2,
		magmaDoubleComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 1 vectors such that.

skp[0] = [ <v_0,w_0> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaDoubleComplex_ptr input vector
[in]	w0	magmaDoubleComplex_ptr input vector
[in]	d1	magmaDoubleComplex_ptr workspace
[in]	d2	magmaDoubleComplex_ptr workspace
[out]	skp	magmaDoubleComplex_ptr vector[4] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_zmdotc2()

magma_int_t magma_zmdotc2	(	magma_int_t	n,
		magmaDoubleComplex_ptr	v0,
		magmaDoubleComplex_ptr	w0,
		magmaDoubleComplex_ptr	v1,
		magmaDoubleComplex_ptr	w1,
		magmaDoubleComplex_ptr	d1,
		magmaDoubleComplex_ptr	d2,
		magmaDoubleComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 2 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaDoubleComplex_ptr input vector
[in]	w0	magmaDoubleComplex_ptr input vector
[in]	v1	magmaDoubleComplex_ptr input vector
[in]	w1	magmaDoubleComplex_ptr input vector
[in]	d1	magmaDoubleComplex_ptr workspace
[in]	d2	magmaDoubleComplex_ptr workspace
[out]	skp	magmaDoubleComplex_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

◆ magma_zmdotc3()

magma_int_t magma_zmdotc3	(	magma_int_t	n,
		magmaDoubleComplex_ptr	v0,
		magmaDoubleComplex_ptr	w0,
		magmaDoubleComplex_ptr	v1,
		magmaDoubleComplex_ptr	w1,
		magmaDoubleComplex_ptr	v2,
		magmaDoubleComplex_ptr	w2,
		magmaDoubleComplex_ptr	d1,
		magmaDoubleComplex_ptr	d2,
		magmaDoubleComplex_ptr	skp,
		magma_queue_t	queue )

Computes the scalar product of a set of 4 vectors such that.

skp[0,1,2,3] = [ <v_0,w_0>, <v_1,w_1>, <v_2,w_2>, <v3,w_3> ]

Returns the vector skp. In case there are less dot products required, an easy workaround is given by doubling input.

Parameters

[in]	n	int length of v_i and w_i
[in]	v0	magmaDoubleComplex_ptr input vector
[in]	w0	magmaDoubleComplex_ptr input vector
[in]	v1	magmaDoubleComplex_ptr input vector
[in]	w1	magmaDoubleComplex_ptr input vector
[in]	v2	magmaDoubleComplex_ptr input vector
[in]	w2	magmaDoubleComplex_ptr input vector
[in]	d1	magmaDoubleComplex_ptr workspace
[in]	d2	magmaDoubleComplex_ptr workspace
[out]	skp	magmaDoubleComplex_ptr vector[3] of scalar products [<v_i, w_i>] This vector is located on the host
[in]	queue	magma_queue_t Queue to execute in.

Functions

Detailed Description

Function Documentation

◆ magma_ccustomspmv()

◆ magma_cge3pt()

◆ magma_cgecsrmv()

◆ magma_cgecsrmv_shift()

◆ magma_cgeellmv()

◆ magma_cgeellmv_shift()

◆ magma_cgeellrtmv()

◆ magma_cgeelltmv_shift()

◆ magma_cmdotc()

vectors v_i

◆ magma_cgesellpmv()

◆ magma_cgesellcmv()

◆ magma_cmdotc_shfl()

vectors v_i

◆ magma_cmdotc1()

◆ magma_cmdotc2()

◆ magma_cmdotc3()

◆ magma_cmdotc4()

◆ magma_cmgecsrmv()

◆ magma_cmgeellmv()

◆ magma_cmgeelltmv()

◆ magma_cmgesellpmv()

◆ magma_dmdotc1()

◆ magma_dmdotc2()

◆ magma_dmdotc3()

◆ magma_c_spmv()

◆ magma_c_spmv_shift()

◆ magma_c_spmm()

◆ magma_ccuspaxpy()

◆ magma_ccuspmm()

◆ magma_smdotc1()

◆ magma_smdotc2()

◆ magma_smdotc3()

◆ magma_zmdotc1()

◆ magma_zmdotc2()

◆ magma_zmdotc3()