Loading...
Searching...
No Matches
single-complex precision
Sparse LA » Sparse BLAS

## 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_cgeaxpy (magmaFloatComplex alpha, magma_c_matrix X, magmaFloatComplex beta, magma_c_matrix *Y, magma_queue_t queue)
| This routine computes Y = alpha * X + beta * Y on the GPU.

magma_int_t

magma_cgecsr5mv (magma_trans_t transA, magma_int_t m, magma_int_t n, magma_int_t p, magmaFloatComplex alpha, magma_int_t sigma, magma_int_t bit_y_offset, magma_int_t bit_scansum_offset, magma_int_t num_packet, magmaUIndex_ptr dtile_ptr, magmaUIndex_ptr dtile_desc, magmaIndex_ptr dtile_desc_offset_ptr, magmaIndex_ptr dtile_desc_offset, magmaFloatComplex_ptr dcalibrator, magma_int_t tail_tile_start, 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 (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_cgecsrreimsplit (magma_c_matrix A, magma_c_matrix *ReA, magma_c_matrix *ImA, magma_queue_t queue)
| This routine takes an input matrix A in CSR format and located on the GPU and splits it into two matrixes ReA and ImA containing the real and the imaginary contributions of A.
magma_int_t | magma_cgedensereimsplit (magma_c_matrix A, magma_c_matrix *ReA, magma_c_matrix *ImA, magma_queue_t queue)
| This routine takes an input matrix A in DENSE format and located on the GPU and splits it into two matrixes ReA and ImA containing the real and the imaginary contributions of A.
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_cgeaxpy()

magma_int_t magma_cgeaxpy | ( | magmaFloatComplex | alpha,
|  | magma_c_matrix | X,
|  | magmaFloatComplex | beta,
|  | magma_c_matrix * | Y,
|  | magma_queue_t | queue )

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

The input format is magma_c_matrix. It can handle both, dense matrix (vector block) and CSR matrices. For the latter, it interfaces the cuSPARSE library.

Parameters

  [in] | alpha | magmaFloatComplex scalar multiplier.
  [in] | X | magma_c_matrix input/output matrix Y.
  [in] | beta | magmaFloatComplex scalar multiplier.
  [in,out] | Y | magma_c_matrix* input matrix X.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_cgecsr5mv()

magma_int_t magma_cgecsr5mv | ( | magma_trans_t | transA,
|  | magma_int_t | m,
|  | magma_int_t | n,
|  | magma_int_t | p,
|  | magmaFloatComplex | alpha,
|  | magma_int_t | sigma,
|  | magma_int_t | bit_y_offset,
|  | magma_int_t | bit_scansum_offset,
|  | magma_int_t | num_packet,
|  | magmaUIndex_ptr | dtile_ptr,
|  | magmaUIndex_ptr | dtile_desc,
|  | magmaIndex_ptr | dtile_desc_offset_ptr,
|  | magmaIndex_ptr | dtile_desc_offset,
|  | magmaFloatComplex_ptr | dcalibrator,
|  | magma_int_t | tail_tile_start,
|  | 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 CSR5 (val (tile-wise column-major), row_pointer, col (tile-wise column-major), tile_pointer, tile_desc).

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] | p | magma_int_t number of tiles in A
  [in] | alpha | magmaFloatComplex scalar multiplier
  [in] | sigma | magma_int_t sigma in A in CSR5
  [in] | bit_y_offset | magma_int_t bit_y_offset in A in CSR5
  [in] | bit_scansum_offset | magma_int_t bit_scansum_offset in A in CSR5
  [in] | num_packet | magma_int_t num_packet in A in CSR5
  [in] | dtile_ptr | magmaUIndex_ptr tilepointer of A in CSR5
  [in] | dtile_desc | magmaUIndex_ptr tiledescriptor of A in CSR5
  [in] | dtile_desc_offset_ptr | magmaIndex_ptr tiledescriptor_offsetpointer of A in CSR5
  [in] | dtile_desc_offset | magmaIndex_ptr tiledescriptor_offsetpointer of A in CSR5
  [in] | dcalibrator | magmaFloatComplex_ptr calibrator of A in CSR5
  [in] | tail_tile_start | magma_int_t start of the last tile in A
  [in] | dval | magmaFloatComplex_ptr array containing values of A in CSR
  [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()

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

magma_int_t magma_cgecsrreimsplit | ( | magma_c_matrix | A,
|  | magma_c_matrix * | ReA,
|  | magma_c_matrix * | ImA,
|  | magma_queue_t | queue )

This routine takes an input matrix A in CSR format and located on the GPU and splits it into two matrixes ReA and ImA containing the real and the imaginary contributions of A.

The output matrices are allocated within the routine.

Parameters

  [in] | A | magma_c_matrix input matrix A.
  [out] | ReA | magma_c_matrix* output matrix contaning real contributions.
  [out] | ImA | magma_c_matrix* output matrix contaning complex contributions.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_cgedensereimsplit()

magma_int_t magma_cgedensereimsplit | ( | magma_c_matrix | A,
|  | magma_c_matrix * | ReA,
|  | magma_c_matrix * | ImA,
|  | magma_queue_t | queue )

This routine takes an input matrix A in DENSE format and located on the GPU and splits it into two matrixes ReA and ImA containing the real and the imaginary contributions of A.

The output matrices are allocated within the routine.

Parameters

  [in] | A | magma_c_matrix input matrix A.
  [out] | ReA | magma_c_matrix* output matrix contaning real contributions.
  [out] | ImA | magma_c_matrix* output matrix contaning complex contributions.
  [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.