single-complex precision

Functions
magma_int_t	magma_cjacobisetup_matrix (magma_c_matrix A, magma_c_matrix *M, magma_c_matrix *d, magma_queue_t queue)
	Prepares the Matrix M for the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.
magma_int_t	magma_cjacobisetup_diagscal (magma_c_matrix A, magma_c_matrix *d, magma_queue_t queue)
	It returns a vector d containing the inverse diagonal elements.
magma_int_t	magma_cjacobisetup_vector (magma_c_matrix b, magma_c_matrix d, magma_c_matrix *c, magma_queue_t queue)
	Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.
magma_int_t	magma_cjacobisetup (magma_c_matrix A, magma_c_matrix b, magma_c_matrix *M, magma_c_matrix *c, magma_queue_t queue)
	Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.
magma_int_t	magma_cjacobiiter (magma_c_matrix M, magma_c_matrix c, magma_c_matrix *x, magma_c_solver_par *solver_par, magma_queue_t queue)
	Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.
magma_int_t	magma_cjacobiiter_precond (magma_c_matrix M, magma_c_matrix *x, magma_c_solver_par *solver_par, magma_c_preconditioner *precond, magma_queue_t queue)
	Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.
magma_int_t	magma_ccompactActive (magma_int_t m, magma_int_t n, magmaFloatComplex_ptr dA, magma_int_t ldda, magmaInt_ptr active, magma_queue_t queue)
	ZCOMPACTACTIVE takes a set of n vectors of size m (in dA) and an array of 1s and 0sindicating which vectors to compact (for 1s) and which to disregard (for 0s).
magma_int_t	magma_cgeelltmv (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^t * x + beta * y on the GPU.
magma_int_t	magma_cgemvmdot (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)
	This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.
magma_int_t	magma_cjacobi_diagscal (magma_int_t num_rows, magma_c_matrix d, magma_c_matrix b, magma_c_matrix *c, magma_queue_t queue)
	Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.
magma_int_t	magma_cjacobiupdate (magma_c_matrix t, magma_c_matrix b, magma_c_matrix d, magma_c_matrix *x, magma_queue_t queue)
	Updates the iteration vector x for the Jacobi iteration according to x=x+d.
magma_int_t	magma_cjacobispmvupdate (magma_int_t maxiter, magma_c_matrix A, magma_c_matrix t, magma_c_matrix b, magma_c_matrix d, magma_c_matrix *x, magma_queue_t queue)
	Updates the iteration vector x for the Jacobi iteration according to x=x+d.
magma_int_t	magma_cgemvmdot_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)
	This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.

Detailed Description

Function Documentation

magma_cjacobisetup_matrix()

magma_int_t magma_cjacobisetup_matrix	(	magma_c_matrix	A,
		magma_c_matrix *	M,
		magma_c_matrix *	d,
		magma_queue_t	queue )

Prepares the Matrix M for the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

It returns the preconditioner Matrix M and a vector d containing the diagonal elements.

Parameters

[in]	A	magma_c_matrix input matrix A
[in]	M	magma_c_matrix* M = D^(-1) * (L+U)
[in,out]	d	magma_c_matrix* vector with diagonal elements of A
[in]	queue	magma_queue_t Queue to execute in.

magma_cjacobisetup_diagscal()

magma_int_t magma_cjacobisetup_diagscal	(	magma_c_matrix	A,
		magma_c_matrix *	d,
		magma_queue_t	queue )

It returns a vector d containing the inverse diagonal elements.

Parameters

[in]	A	magma_c_matrix input matrix A
[in,out]	d	magma_c_matrix* vector with diagonal elements
[in]	queue	magma_queue_t Queue to execute in.

magma_cjacobisetup_vector()

magma_int_t magma_cjacobisetup_vector	(	magma_c_matrix	b,
		magma_c_matrix	d,
		magma_c_matrix *	c,
		magma_queue_t	queue )

Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

Returns the vector c

Parameters

[in]	b	magma_c_matrix RHS b
[in]	d	magma_c_matrix vector with diagonal entries
[in]	c	magma_c_matrix* c = D^(-1) * b
[in]	queue	magma_queue_t Queue to execute in.

magma_cjacobisetup()

magma_int_t magma_cjacobisetup	(	magma_c_matrix	A,
		magma_c_matrix	b,
		magma_c_matrix *	M,
		magma_c_matrix *	c,
		magma_queue_t	queue )

Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

Parameters

[in]	A	magma_c_matrix input matrix A
[in]	b	magma_c_matrix RHS b
[in]	M	magma_c_matrix* M = D^(-1) * (L+U)
[in]	c	magma_c_matrix* c = D^(-1) * b
[in]	queue	magma_queue_t Queue to execute in.

magma_cjacobiiter()

magma_int_t magma_cjacobiiter	(	magma_c_matrix	M,
		magma_c_matrix	c,
		magma_c_matrix *	x,
		magma_c_solver_par *	solver_par,
		magma_queue_t	queue )

Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

This routine takes the iteration matrix M as input.

Parameters

[in]	M	magma_c_matrix input matrix M = D^(-1) * (L+U)
[in]	c	magma_c_matrix c = D^(-1) * b
[in,out]	x	magma_c_matrix* iteration vector x
[in,out]	solver_par	magma_c_solver_par* solver parameters
[in]	queue	magma_queue_t Queue to execute in.

magma_cjacobiiter_precond()

magma_int_t magma_cjacobiiter_precond	(	magma_c_matrix	M,
		magma_c_matrix *	x,
		magma_c_solver_par *	solver_par,
		magma_c_preconditioner *	precond,
		magma_queue_t	queue )

Iterates the solution approximation according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

Parameters

[in]	M	magma_c_matrix input matrix M = D^(-1) * (L+U)
[in,out]	x	magma_c_matrix* iteration vector x
[in,out]	solver_par	magma_c_solver_par* solver parameters
[in]	precond	magma_c_precond_par* precond parameters
[in]	queue	magma_queue_t Queue to execute in.

magma_ccompactActive()

magma_int_t magma_ccompactActive	(	magma_int_t	m,
		magma_int_t	n,
		magmaFloatComplex_ptr	dA,
		magma_int_t	ldda,
		magmaInt_ptr	active,
		magma_queue_t	queue )

ZCOMPACTACTIVE takes a set of n vectors of size m (in dA) and an array of 1s and 0sindicating which vectors to compact (for 1s) and which to disregard (for 0s).

Parameters

[in]	m	INTEGER The number of rows of the matrix dA. M >= 0.
[in]	n	INTEGER The number of columns of the matrix dA. N >= 0.
[in,out]	dA	COMPLEX REAL array, dimension (LDDA,N) The m by n matrix dA.
[in]	ldda	INTEGER The leading dimension of the array dA. LDDA >= max(1,M).
[in]	active	INTEGER array, dimension N A mask of 1s and 0s showing if a vector remains or has been removed
[in]	queue	magma_queue_t Queue to execute in.

magma_cgeelltmv()

magma_int_t magma_cgeelltmv	(	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^t * 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]	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_cgemvmdot()

magma_int_t magma_cgemvmdot	(	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 )

This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.

It is equivalent to a matrix vecor product Vr where V contains few rows and many columns. The computation is the same:

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_cjacobi_diagscal()

magma_int_t magma_cjacobi_diagscal	(	magma_int_t	num_rows,
		magma_c_matrix	d,
		magma_c_matrix	b,
		magma_c_matrix *	c,
		magma_queue_t	queue )

Prepares the Jacobi Iteration according to x^(k+1) = D^(-1) * b - D^(-1) * (L+U) * x^k x^(k+1) = c - M * x^k.

Returns the vector c. It calls a GPU kernel

Parameters

[in]	num_rows	magma_int_t number of rows
[in]	b	magma_c_matrix RHS b
[in]	d	magma_c_matrix vector with diagonal entries
[out]	c	magma_c_matrix* c = D^(-1) * b
[in]	queue	magma_queue_t Queue to execute in.

magma_cjacobiupdate()

magma_int_t magma_cjacobiupdate	(	magma_c_matrix	t,
		magma_c_matrix	b,
		magma_c_matrix	d,
		magma_c_matrix *	x,
		magma_queue_t	queue )

Updates the iteration vector x for the Jacobi iteration according to x=x+d.

*(b-t) where d is the diagonal of the system matrix A and t=Ax.

Parameters

[in]	t	magma_c_matrix t = A*x
[in]	b	magma_c_matrix RHS b
[in]	d	magma_c_matrix vector with diagonal entries
[out]	x	magma_c_matrix* iteration vector
[in]	queue	magma_queue_t Queue to execute in.

magma_cjacobispmvupdate()

magma_int_t magma_cjacobispmvupdate	(	magma_int_t	maxiter,
		magma_c_matrix	A,
		magma_c_matrix	t,
		magma_c_matrix	b,
		magma_c_matrix	d,
		magma_c_matrix *	x,
		magma_queue_t	queue )

Updates the iteration vector x for the Jacobi iteration according to x=x+d.

*(b-Ax)

Parameters

[in]	maxiter	magma_int_t number of Jacobi iterations
[in]	A	magma_c_matrix system matrix
[in]	t	magma_c_matrix workspace
[in]	b	magma_c_matrix RHS b
[in]	d	magma_c_matrix vector with diagonal entries
[out]	x	magma_c_matrix* iteration vector
[in]	queue	magma_queue_t Queue to execute in.

magma_cgemvmdot_shfl()

magma_int_t magma_cgemvmdot_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 )

This is an extension of the merged dot product above by chunking the set of vectors v_i such that the data always fits into cache.

It is equivalent to a matrix vecor product Vr where V contains few rows and many columns. The computation is the same:

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.