single-complex precision
[Sparse unfiled]

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_cjacobiiter_sys (magma_c_matrix A, magma_c_matrix b, magma_c_matrix d, magma_c_matrix t, 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_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_cjacobi_diagscal (int 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_cjacobispmvupdateselect (magma_int_t maxiter, magma_int_t num_updates, magma_index_t *indices, magma_c_matrix A, magma_c_matrix t, magma_c_matrix b, magma_c_matrix d, magma_c_matrix tmp, 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 (int n, int 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_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_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.

Function Documentation

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_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_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] 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_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_int_t magma_cgemvmdot ( int  n,
int  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
[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_int_t magma_cjacobi_diagscal ( int  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_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_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] 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] solver_par magma_c_precond_par* precond parameters
[in] queue magma_queue_t Queue to execute in.
magma_int_t magma_cjacobiiter_sys ( magma_c_matrix  A,
magma_c_matrix  b,
magma_c_matrix  d,
magma_c_matrix  t,
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 system matrix A and the RHS b 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_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_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_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_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_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_int_t magma_cjacobispmvupdateselect ( magma_int_t  maxiter,
magma_int_t  num_updates,
magma_index_t *  indices,
magma_c_matrix  A,
magma_c_matrix  t,
magma_c_matrix  b,
magma_c_matrix  d,
magma_c_matrix  tmp,
magma_c_matrix *  x,
magma_queue_t  queue 
)

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

*(b-Ax)

This kernel allows for overlapping domains: the indices-array contains the locations that are updated. Locations may be repeated to simulate overlapping domains.

Parameters:
[in] maxiter magma_int_t number of Jacobi iterations
[in] num_updates magma_int_t number of updates - length of the indices array
[in] indices magma_index_t* indices, which entries of x to update
[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
[in] tmp magma_c_matrix workspace
[out] x magma_c_matrix* iteration vector
[in] queue magma_queue_t Queue to execute in.
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] num_rows magma_int_t number of rows
[in] num_cols magma_int_t number of cols
[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.

Generated on 3 May 2015 for MAGMA by  doxygen 1.6.1