single-complex precision
[Sparse unfiled]

Functions

void magma_ccompactActive (magma_int_t m, magma_int_t n, magmaFloatComplex *dA, magma_int_t ldda, magma_index_t *active)
 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 *d_val, magma_index_t *d_colind, magmaFloatComplex *d_x, magmaFloatComplex beta, magmaFloatComplex *d_y)
 This routine computes y = alpha * A^t * x + beta * y on the GPU.
magma_int_t magma_cjacobi_diagscal (int num_rows, magmaFloatComplex *b, magmaFloatComplex *d, magmaFloatComplex *c)
 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_cgemvmdot (int n, int k, magmaFloatComplex *v, magmaFloatComplex *r, magmaFloatComplex *d1, magmaFloatComplex *d2, magmaFloatComplex *skp)
 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_sparse_matrix A, magma_c_vector x, magmaFloatComplex beta, magma_c_vector y)
 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.

Function Documentation

magma_int_t magma_c_spmv ( magmaFloatComplex  alpha,
magma_c_sparse_matrix  A,
magma_c_vector  x,
magmaFloatComplex  beta,
magma_c_vector  y 
)

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:
alpha magmaFloatComplex scalar alpha
A magma_c_sparse_matrix sparse matrix A
x magma_c_vector input vector x
beta magmaFloatComplex scalar beta
y magma_c_vector output vector y
void magma_ccompactActive ( magma_int_t  m,
magma_int_t  n,
magmaFloatComplex *  dA,
magma_int_t  ldda,
magma_index_t *  active 
)

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
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 *  d_val,
magma_index_t *  d_colind,
magmaFloatComplex *  d_x,
magmaFloatComplex  beta,
magmaFloatComplex *  d_y 
)

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

Input format is ELL.

Parameters:
transA magma_trans_t transposition parameter for A
m magma_int_t number of rows in A
n magma_int_t number of columns in A
nnz_per_row magma_int_t number of elements in the longest row
alpha magmaFloatComplex scalar multiplier
d_val magmaFloatComplex* array containing values of A in ELL
d_colind magma_int_t* columnindices of A in ELL
d_x magmaFloatComplex* input vector x
beta magmaFloatComplex scalar multiplier
d_y magmaFloatComplex* input/output vector y
magma_int_t magma_cgemvmdot ( int  n,
int  k,
magmaFloatComplex *  v,
magmaFloatComplex *  r,
magmaFloatComplex *  d1,
magmaFloatComplex *  d2,
magmaFloatComplex *  skp 
)

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:
n int length of v_i and r
k int # vectors v_i
v magmaFloatComplex* v = (v_0 .. v_i.. v_k)
r magmaFloatComplex* r
d1 magmaFloatComplex* workspace
d2 magmaFloatComplex* workspace
skp magmaFloatComplex* vector[k] of scalar products (<v_i,r>...)
magma_int_t magma_cjacobi_diagscal ( int  num_rows,
magmaFloatComplex *  b,
magmaFloatComplex *  d,
magmaFloatComplex *  c 
)

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:
num_rows magma_int_t number of rows
b magma_c_vector RHS b
d magma_c_vector vector with diagonal entries
c magma_c_vector* c = D^(-1) * b

Generated on 17 Sep 2014 for MAGMA by  doxygen 1.6.1