MAGMA  2.0.0
Matrix Algebra for GPU and Multicore Architectures
 All Classes Files Functions Friends Groups Pages
single precision

Functions

magma_int_t magma_s_precond (magma_s_matrix A, magma_s_matrix b, magma_s_matrix *x, magma_s_preconditioner *precond, magma_queue_t queue)
 For a given input matrix A and vectors x, y and the preconditioner parameters, the respective preconditioner is chosen. More...
 
magma_int_t magma_s_precondsetup (magma_s_matrix A, magma_s_matrix b, magma_s_solver_par *solver, magma_s_preconditioner *precond, magma_queue_t queue)
 For a given input matrix M and vectors x, y and the preconditioner parameters, the respective preconditioner is preprocessed. More...
 
magma_int_t magma_s_applyprecond (magma_s_matrix A, magma_s_matrix b, magma_s_matrix *x, magma_s_preconditioner *precond, magma_queue_t queue)
 For a given input matrix A and vectors x, y and the preconditioner parameters, the respective preconditioner is applied. More...
 
magma_int_t magma_s_applyprecond_left (magma_trans_t trans, magma_s_matrix A, magma_s_matrix b, magma_s_matrix *x, magma_s_preconditioner *precond, magma_queue_t queue)
 For a given input matrix A and vectors x, y and the preconditioner parameters, the respective left preconditioner is applied. More...
 
magma_int_t magma_s_applyprecond_right (magma_trans_t trans, magma_s_matrix A, magma_s_matrix b, magma_s_matrix *x, magma_s_preconditioner *precond, magma_queue_t queue)
 For a given input matrix A and vectors x, y and the preconditioner parameters, the respective right-preconditioner is applied. More...
 
magma_int_t magma_s_solver (magma_s_matrix A, magma_s_matrix b, magma_s_matrix *x, magma_sopts *zopts, magma_queue_t queue)
 Allows the user to choose a solver. More...
 
magma_int_t magma_sapplycustomprecond_l (magma_s_matrix b, magma_s_matrix *x, magma_s_preconditioner *precond, magma_queue_t queue)
 This is an interface to the left solve for any custom preconditioner. More...
 
magma_int_t magma_sapplycustomprecond_r (magma_s_matrix b, magma_s_matrix *x, magma_s_preconditioner *precond, magma_queue_t queue)
 This is an interface to the right solve for any custom preconditioner. More...
 
magma_int_t magma_sresidual (magma_s_matrix A, magma_s_matrix b, magma_s_matrix x, float *res, magma_queue_t queue)
 Computes the residual ||b-Ax|| for a solution approximation x. More...
 
magma_int_t magma_sresidual_slice (magma_int_t start, magma_int_t end, magma_s_matrix A, magma_s_matrix b, magma_s_matrix x, float *res, magma_queue_t queue)
 Computes the residual r=||b-Ax|| for the slice r(start:end) for a solution approximation x. More...
 
magma_int_t magma_sresidualvec (magma_s_matrix A, magma_s_matrix b, magma_s_matrix x, magma_s_matrix *r, float *res, magma_queue_t queue)
 Computes the residual r = b-Ax for a solution approximation x. More...
 
magma_int_t magma_scsrsplit (magma_int_t offset, magma_int_t bsize, magma_s_matrix A, magma_s_matrix *D, magma_s_matrix *R, magma_queue_t queue)
 Splits a CSR matrix into two matrices, one containing the diagonal blocks with the diagonal element stored first, one containing the rest of the original matrix. More...
 
magma_int_t magma_sdomainoverlap (magma_index_t num_rows, magma_int_t *num_indices, magma_index_t *rowptr, magma_index_t *colidx, magma_index_t *x, magma_queue_t queue)
 Generates the update list. More...
 
magma_int_t magma_smfree (magma_s_matrix *A, magma_queue_t queue)
 Free the memory of a magma_s_matrix. More...
 
magma_int_t magma_sfrobenius (magma_s_matrix A, magma_s_matrix B, real_Double_t *res, magma_queue_t queue)
 Computes the Frobenius norm of the difference between the CSR matrices A and B. More...
 
magma_int_t magma_snonlinres (magma_s_matrix A, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *LU, real_Double_t *res, magma_queue_t queue)
 Computes the nonlinear residual A - LU and returns the difference as well es the Frobenius norm of the difference. More...
 
magma_int_t magma_silures (magma_s_matrix A, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *LU, real_Double_t *res, real_Double_t *nonlinres, magma_queue_t queue)
 Computes the ILU residual A - LU and returns the difference as well es the Frobenius norm of the difference. More...
 
magma_int_t magma_sicres (magma_s_matrix A, magma_s_matrix C, magma_s_matrix CT, magma_s_matrix *LU, real_Double_t *res, real_Double_t *nonlinres, magma_queue_t queue)
 Computes the IC residual A - CC^T and returns the difference as well es the Frobenius norm of the difference. More...
 
magma_int_t magma_sinitguess (magma_s_matrix A, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
 Computes an initial guess for the iterative ILU/IC. More...
 
magma_int_t magma_sinitrecursiveLU (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
 Using the iterative approach of computing ILU factorizations with increasing fill-in, it takes the input matrix A, containing the approximate factors, ( L and U as well ) computes a matrix with one higher level of fill-in, inserts the original approximation as initial guess, and provides the factors L and U also filled with the scaled initial guess. More...
 
magma_int_t magma_smLdiagadd (magma_s_matrix *L, magma_queue_t queue)
 Checks for a lower triangular matrix whether it is strictly lower triangular and in the negative case adds a unit diagonal. More...
 
magma_int_t magma_srowentries (magma_s_matrix *A, magma_queue_t queue)
 Checks the maximal number of nonzeros in a row of matrix A. More...
 
magma_int_t magma_sdiameter (magma_s_matrix *A, magma_queue_t queue)
 Computes the diameter of a sparse matrix and stores the value in diameter. More...
 
magma_int_t magma_s_csr_compressor (float **val, magma_index_t **row, magma_index_t **col, float **valn, magma_index_t **rown, magma_index_t **coln, magma_int_t *n, magma_queue_t queue)
 Helper function to compress CSR containing zero-entries. More...
 
magma_int_t magma_smconvert (magma_s_matrix A, magma_s_matrix *B, magma_storage_t old_format, magma_storage_t new_format, magma_queue_t queue)
 Converter between different sparse storage formats. More...
 
magma_int_t magma_smcsrcompressor (magma_s_matrix *A, magma_queue_t queue)
 Removes zeros in a CSR matrix. More...
 
magma_int_t magma_scsrset (magma_int_t m, magma_int_t n, magma_index_t *row, magma_index_t *col, float *val, magma_s_matrix *A, magma_queue_t queue)
 Passes a CSR matrix to MAGMA. More...
 
magma_int_t magma_scsrget (magma_s_matrix A, magma_int_t *m, magma_int_t *n, magma_index_t **row, magma_index_t **col, float **val, magma_queue_t queue)
 Passes a MAGMA matrix to CSR structure. More...
 
magma_int_t magma_scsrset_gpu (magma_int_t m, magma_int_t n, magmaIndex_ptr row, magmaIndex_ptr col, magmaFloat_ptr val, magma_s_matrix *A, magma_queue_t queue)
 Passes a CSR matrix to MAGMA (located on DEV). More...
 
magma_int_t magma_scsrget_gpu (magma_s_matrix A, magma_int_t *m, magma_int_t *n, magmaIndex_ptr *row, magmaIndex_ptr *col, magmaFloat_ptr *val, magma_queue_t queue)
 Passes a MAGMA matrix to CSR structure (located on DEV). More...
 
magma_int_t magma_smdiff (magma_s_matrix A, magma_s_matrix B, real_Double_t *res, magma_queue_t queue)
 Computes the Frobenius norm of the difference between the CSR matrices A and B. More...
 
magma_int_t magma_smgenerator (magma_int_t n, magma_int_t offdiags, magma_index_t *diag_offset, float *diag_vals, magma_s_matrix *A, magma_queue_t queue)
 Generate a symmetric n x n CSR matrix for a stencil. More...
 
magma_int_t magma_sm_27stencil (magma_int_t n, magma_s_matrix *A, magma_queue_t queue)
 Generate a 27-point stencil for a 3D FD discretization. More...
 
magma_int_t magma_sm_5stencil (magma_int_t n, magma_s_matrix *A, magma_queue_t queue)
 Generate a 5-point stencil for a 2D FD discretization. More...
 
magma_int_t magma_ssymbilu (magma_s_matrix *A, magma_int_t levels, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
 This routine performs a symbolic ILU factorization. More...
 
magma_int_t read_s_csr_from_mtx (magma_storage_t *type, magma_location_t *location, magma_int_t *n_row, magma_int_t *n_col, magma_int_t *nnz, float **val, magma_index_t **row, magma_index_t **col, const char *filename, magma_queue_t queue)
 Reads in a matrix stored in coo format from a Matrix Market (.mtx) file and converts it into CSR format. More...
 
magma_int_t magma_swrite_csr_mtx (magma_s_matrix A, magma_order_t MajorType, const char *filename, magma_queue_t queue)
 Writes a CSR matrix to a file using Matrix Market format. More...
 
magma_int_t magma_sprint_csr_mtx (magma_int_t n_row, magma_int_t n_col, magma_int_t nnz, float **val, magma_index_t **row, magma_index_t **col, magma_order_t MajorType, magma_queue_t queue)
 Prints a CSR matrix in Matrix Market format. More...
 
magma_int_t magma_sprint_csr (magma_int_t n_row, magma_int_t n_col, magma_int_t nnz, float **val, magma_index_t **row, magma_index_t **col, magma_queue_t queue)
 Prints a CSR matrix in CSR format. More...
 
magma_int_t magma_sprint_matrix (magma_s_matrix A, magma_queue_t queue)
 Prints a sparse matrix in CSR format. More...
 
magma_int_t magma_s_csr_mtx (magma_s_matrix *A, const char *filename, magma_queue_t queue)
 Reads in a matrix stored in coo format from a Matrix Market (.mtx) file and converts it into CSR format. More...
 
magma_int_t magma_s_csr_mtxsymm (magma_s_matrix *A, const char *filename, magma_queue_t queue)
 Reads in a SYMMETRIC matrix stored in coo format from a Matrix Market (.mtx) file and converts it into CSR format. More...
 
magma_int_t magma_smlumerge (magma_s_matrix L, magma_s_matrix U, magma_s_matrix *A, magma_queue_t queue)
 Takes an strictly lower triangular matrix L and an upper triangular matrix U and merges them into a matrix A containing the upper and lower triangular parts. More...
 
magma_int_t magma_smscale (magma_s_matrix *A, magma_scale_t scaling, magma_queue_t queue)
 Scales a matrix. More...
 
magma_int_t magma_smdiagadd (magma_s_matrix *A, float add, magma_queue_t queue)
 Adds a multiple of the Identity matrix to a matrix: A = A+add * I. More...
 
magma_int_t magma_smshrink (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
 Shrinks a non-square matrix (m < n) to the smaller dimension. More...
 
magma_int_t magma_smslice (magma_int_t num_slices, magma_int_t slice, magma_s_matrix A, magma_s_matrix *B, magma_s_matrix *ALOC, magma_s_matrix *ANLOC, magma_index_t *comm_i, float *comm_v, magma_int_t *start, magma_int_t *end, magma_queue_t queue)
 Takes a matrix and extracts a slice for solving the system in parallel: More...
 
magma_int_t magma_smtransfer (magma_s_matrix A, magma_s_matrix *B, magma_location_t src, magma_location_t dst, magma_queue_t queue)
 Copies a matrix from memory location src to memory location dst. More...
 
magma_int_t s_transpose_csr (magma_int_t n_rows, magma_int_t n_cols, magma_int_t nnz, float *values, magma_index_t *rowptr, magma_index_t *colind, magma_int_t *new_n_rows, magma_int_t *new_n_cols, magma_int_t *new_nnz, float **new_values, magma_index_t **new_rowptr, magma_index_t **new_colind, magma_queue_t queue)
 Transposes a matrix stored in CSR format on the CPU host. More...
 
magma_int_t magma_smtranspose (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
 Interface to cuSPARSE transpose. More...
 
magma_int_t magma_s_cucsrtranspose (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
 Helper function to transpose CSR matrix. More...
 
magma_int_t magma_smtransposeconjugate (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
 This function forms the transpose conjugate of a matrix. More...
 
magma_int_t magma_ssolverinfo (magma_s_solver_par *solver_par, magma_s_preconditioner *precond_par, magma_queue_t queue)
 Prints information about a previously called solver. More...
 
magma_int_t magma_ssolverinfo_free (magma_s_solver_par *solver_par, magma_s_preconditioner *precond_par, magma_queue_t queue)
 Frees any memory assocoiated with the verbose mode of solver_par. More...
 
magma_int_t magma_ssolverinfo_init (magma_s_solver_par *solver_par, magma_s_preconditioner *precond_par, magma_queue_t queue)
 Initializes all solver and preconditioner parameters. More...
 
magma_int_t magma_seigensolverinfo_init (magma_s_solver_par *solver_par, magma_queue_t queue)
 Initializes space for eigensolvers. More...
 
magma_int_t magma_ssort (float *x, magma_int_t first, magma_int_t last, magma_queue_t queue)
 Sorts an array of values in increasing order. More...
 
magma_int_t magma_smsort (float *x, magma_index_t *col, magma_index_t *row, magma_int_t first, magma_int_t last, magma_queue_t queue)
 Sorts an array of values in increasing order. More...
 
magma_int_t magma_sindexsort (magma_index_t *x, magma_int_t first, magma_int_t last, magma_queue_t queue)
 Sorts an array of integers in increasing order. More...
 
magma_int_t magma_sindexsortval (magma_index_t *x, float *y, magma_int_t first, magma_int_t last, magma_queue_t queue)
 Sorts an array of integers, updates a respective array of values. More...
 
magma_int_t magma_smorderstatistics (float *val, magma_index_t *col, magma_index_t *row, magma_int_t length, magma_int_t k, magma_int_t r, float *element, magma_queue_t queue)
 Identifies the kth smallest/largest element in an array and reorders such that these elements come to the front. More...
 
magma_int_t magma_sorderstatistics (float *val, magma_int_t length, magma_int_t k, magma_int_t r, float *element, magma_queue_t queue)
 Identifies the kth smallest/largest element in an array. More...
 
magma_int_t magma_sparse_opts (int argc, char **argv, magma_sopts *opts, int *matrices, magma_queue_t queue)
 Parses input options for a solver. More...
 
magma_int_t magma_svinit (magma_s_matrix *x, magma_location_t mem_loc, magma_int_t num_rows, magma_int_t num_cols, float values, magma_queue_t queue)
 Allocates memory for magma_s_matrix and initializes it with the passed value. More...
 
magma_int_t magma_sprint_vector (magma_s_matrix x, magma_int_t offset, magma_int_t visulen, magma_queue_t queue)
 Visualizes part of a vector of type magma_s_matrix. More...
 
magma_int_t magma_svread (magma_s_matrix *x, magma_int_t length, char *filename, magma_queue_t queue)
 Reads in a float vector of length "length". More...
 
magma_int_t magma_svspread (magma_s_matrix *x, const char *filename, magma_queue_t queue)
 Reads in a sparse vector-block stored in COO format. More...
 
magma_int_t magma_svset (magma_int_t m, magma_int_t n, float *val, magma_s_matrix *v, magma_queue_t queue)
 Passes a vector to MAGMA. More...
 
magma_int_t magma_svget (magma_s_matrix v, magma_int_t *m, magma_int_t *n, float **val, magma_queue_t queue)
 Passes a MAGMA vector back. More...
 
magma_int_t magma_svset_dev (magma_int_t m, magma_int_t n, magmaFloat_ptr val, magma_s_matrix *v, magma_queue_t queue)
 Passes a vector to MAGMA (located on DEV). More...
 
magma_int_t magma_svget_dev (magma_s_matrix v, magma_int_t *m, magma_int_t *n, magmaFloat_ptr *val, magma_queue_t queue)
 Passes a MAGMA vector back (located on DEV). More...
 
magma_int_t magma_svtranspose (magma_s_matrix x, magma_s_matrix *y, magma_queue_t queue)
 Transposes a vector from col to row major and vice versa. More...
 
magma_int_t magma_sdiagcheck (magma_s_matrix dA, magma_queue_t queue)
 This routine checks for a CSR matrix whether there exists a zero on the diagonal. More...
 
magma_int_t magma_smconjugate (magma_s_matrix *A, magma_queue_t queue)
 This function conjugates a matrix. More...
 
magma_int_t magma_smcsrcompressor_gpu (magma_s_matrix *A, magma_queue_t queue)
 Removes zeros in a CSR matrix. More...
 
magma_int_t magma_slobpcg_res (magma_int_t num_rows, magma_int_t num_vecs, magmaFloat_ptr evalues, magmaFloat_ptr X, magmaFloat_ptr R, magmaFloat_ptr res, magma_queue_t queue)
 This routine computes for Block-LOBPCG, the set of residuals. More...
 
magma_int_t magma_slobpcg_shift (magma_int_t num_rows, magma_int_t num_vecs, magma_int_t shift, magmaFloat_ptr x, magma_queue_t queue)
 For a Block-LOBPCG, the set of residuals (entries consecutive in memory) shrinks and the vectors are shifted in case shift residuals drop below threshold. More...
 
magma_int_t magma_scopyscale (magma_int_t n, magma_int_t k, magmaFloat_ptr r, magmaFloat_ptr v, magmaFloat_ptr skp, magma_queue_t queue)
 Computes the correction term of the pipelined GMRES according to P. More...
 

Detailed Description

Function Documentation

magma_int_t magma_s_applyprecond ( magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix *  x,
magma_s_preconditioner *  precond,
magma_queue_t  queue 
)

For a given input matrix A and vectors x, y and the preconditioner parameters, the respective preconditioner is applied.

E.g. for Jacobi: the scaling-vetor, for ILU the triangular solves.

Parameters
[in]Amagma_s_matrix sparse matrix A
[in]bmagma_s_matrix input vector b
[in,out]xmagma_s_matrix* output vector x
[in]precondmagma_s_preconditioner preconditioner
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_applyprecond_left ( magma_trans_t  trans,
magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix *  x,
magma_s_preconditioner *  precond,
magma_queue_t  queue 
)

For a given input matrix A and vectors x, y and the preconditioner parameters, the respective left preconditioner is applied.

E.g. for Jacobi: the scaling-vetor, for ILU the left triangular solve.

Parameters
[in]Amagma_s_matrix sparse matrix A
[in]bmagma_s_matrix input vector b
[in,out]xmagma_s_matrix* output vector x
[in]precondmagma_s_preconditioner preconditioner
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_applyprecond_right ( magma_trans_t  trans,
magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix *  x,
magma_s_preconditioner *  precond,
magma_queue_t  queue 
)

For a given input matrix A and vectors x, y and the preconditioner parameters, the respective right-preconditioner is applied.

E.g. for Jacobi: the scaling-vetor, for ILU the right triangular solve.

Parameters
[in]Amagma_s_matrix sparse matrix A
[in]bmagma_s_matrix input vector b
[in,out]xmagma_s_matrix* output vector x
[in]precondmagma_s_preconditioner preconditioner
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_csr_compressor ( float **  val,
magma_index_t **  row,
magma_index_t **  col,
float **  valn,
magma_index_t **  rown,
magma_index_t **  coln,
magma_int_t *  n,
magma_queue_t  queue 
)

Helper function to compress CSR containing zero-entries.

Parameters
[in]valfloat** input val pointer to compress
[in]rowmagma_int_t** input row pointer to modify
[in]colmagma_int_t** input col pointer to compress
[in]valnfloat** output val pointer
[out]rownmagma_int_t** output row pointer
[out]colnmagma_int_t** output col pointer
[out]nmagma_int_t* number of rows in matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_csr_mtx ( magma_s_matrix *  A,
const char *  filename,
magma_queue_t  queue 
)

Reads in a matrix stored in coo format from a Matrix Market (.mtx) file and converts it into CSR format.

It duplicates the off-diagonal entries in the symmetric case.

Parameters
[out]Amagma_s_matrix* matrix in magma sparse matrix format
[in]filenameconst char* filname of the mtx matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_csr_mtxsymm ( magma_s_matrix *  A,
const char *  filename,
magma_queue_t  queue 
)

Reads in a SYMMETRIC matrix stored in coo format from a Matrix Market (.mtx) file and converts it into CSR format.

It does not duplicate the off-diagonal entries!

Parameters
[out]Amagma_s_matrix* matrix in magma sparse matrix format
[in]filenameconst char* filname of the mtx matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_cucsrtranspose ( magma_s_matrix  A,
magma_s_matrix *  B,
magma_queue_t  queue 
)

Helper function to transpose CSR matrix.

Using the CUSPARSE CSR2CSC function.

Parameters
[in]Amagma_s_matrix input matrix (CSR)
[out]Bmagma_s_matrix* output matrix (CSR)
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_precond ( magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix *  x,
magma_s_preconditioner *  precond,
magma_queue_t  queue 
)

For a given input matrix A and vectors x, y and the preconditioner parameters, the respective preconditioner is chosen.

It approximates x for A x = y.

Parameters
[in]Amagma_s_matrix sparse matrix A
[in]bmagma_s_matrix input vector b
[in]xmagma_s_matrix* output vector x
[in,out]precondmagma_s_preconditioner preconditioner
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_precondsetup ( magma_s_matrix  A,
magma_s_matrix  b,
magma_s_solver_par *  solver,
magma_s_preconditioner *  precond,
magma_queue_t  queue 
)

For a given input matrix M and vectors x, y and the preconditioner parameters, the respective preconditioner is preprocessed.

E.g. for Jacobi: the scaling-vetor, for ILU the factorization.

Parameters
[in]Amagma_s_matrix sparse matrix M
[in]bmagma_s_matrix input vector y
[in,out]precondmagma_s_preconditioner preconditioner
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_s_solver ( magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix *  x,
magma_sopts *  zopts,
magma_queue_t  queue 
)

Allows the user to choose a solver.

Parameters
[in]Amagma_s_matrix sparse matrix A
[in]bmagma_s_matrix input vector b
[in]xmagma_s_matrix* output vector x
[in]zoptsmagma_sopts options for solver and preconditioner
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sapplycustomprecond_l ( magma_s_matrix  b,
magma_s_matrix *  x,
magma_s_preconditioner *  precond,
magma_queue_t  queue 
)

This is an interface to the left solve for any custom preconditioner.

It should compute x = FUNCTION(b) The vectors are located on the device.

Parameters
[in]bmagma_s_matrix RHS
[in,out]xmagma_s_matrix* vector to precondition
[in,out]precondmagma_s_preconditioner* preconditioner parameters
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sapplycustomprecond_r ( magma_s_matrix  b,
magma_s_matrix *  x,
magma_s_preconditioner *  precond,
magma_queue_t  queue 
)

This is an interface to the right solve for any custom preconditioner.

It should compute x = FUNCTION(b) The vectors are located on the device.

Parameters
[in]bmagma_s_matrix RHS
[in,out]xmagma_s_matrix* vector to precondition
[in,out]precondmagma_s_preconditioner* preconditioner parameters
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_scopyscale ( magma_int_t  n,
magma_int_t  k,
magmaFloat_ptr  r,
magmaFloat_ptr  v,
magmaFloat_ptr  skp,
magma_queue_t  queue 
)

Computes the correction term of the pipelined GMRES according to P.

Ghysels and scales and copies the new search direction

Returns the vector v = r/ ( skp[k] - (sum_i=1^k skp[i]^2) ) .

Parameters
[in]nint length of v_i
[in]kint

skp entries v_i^T * r ( without r )

Parameters
[in]rmagmaFloat_ptr vector of length n
[in]vmagmaFloat_ptr vector of length n
[in]skpmagmaFloat_ptr array of parameters
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_scsrget ( magma_s_matrix  A,
magma_int_t *  m,
magma_int_t *  n,
magma_index_t **  row,
magma_index_t **  col,
float **  val,
magma_queue_t  queue 
)

Passes a MAGMA matrix to CSR structure.

Parameters
[in]Amagma_s_matrix magma sparse matrix in CSR format
[out]mmagma_int_t number of rows
[out]nmagma_int_t number of columns
[out]rowmagma_index_t* row pointer
[out]colmagma_index_t* column indices
[out]valfloat* array containing matrix entries
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_scsrget_gpu ( magma_s_matrix  A,
magma_int_t *  m,
magma_int_t *  n,
magmaIndex_ptr *  row,
magmaIndex_ptr *  col,
magmaFloat_ptr *  val,
magma_queue_t  queue 
)

Passes a MAGMA matrix to CSR structure (located on DEV).

Parameters
[in]Amagma_s_matrix magma sparse matrix in CSR format
[out]mmagma_int_t number of rows
[out]nmagma_int_t number of columns
[out]rowmagmaIndex_ptr row pointer
[out]colmagmaIndex_ptr column indices
[out]valmagmaFloat_ptr array containing matrix entries
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_scsrset ( magma_int_t  m,
magma_int_t  n,
magma_index_t *  row,
magma_index_t *  col,
float *  val,
magma_s_matrix *  A,
magma_queue_t  queue 
)

Passes a CSR matrix to MAGMA.

Parameters
[in]mmagma_int_t number of rows
[in]nmagma_int_t number of columns
[in]rowmagma_index_t* row pointer
[in]colmagma_index_t* column indices
[in]valfloat* array containing matrix entries
[out]Amagma_s_matrix* matrix in magma sparse matrix format
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_scsrset_gpu ( magma_int_t  m,
magma_int_t  n,
magmaIndex_ptr  row,
magmaIndex_ptr  col,
magmaFloat_ptr  val,
magma_s_matrix *  A,
magma_queue_t  queue 
)

Passes a CSR matrix to MAGMA (located on DEV).

Parameters
[in]mmagma_int_t number of rows
[in]nmagma_int_t number of columns
[in]rowmagmaIndex_ptr row pointer
[in]colmagmaIndex_ptr column indices
[in]valmagmaFloat_ptr array containing matrix entries
[out]Amagma_s_matrix* matrix in magma sparse matrix format
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_scsrsplit ( magma_int_t  offset,
magma_int_t  bsize,
magma_s_matrix  A,
magma_s_matrix *  D,
magma_s_matrix *  R,
magma_queue_t  queue 
)

Splits a CSR matrix into two matrices, one containing the diagonal blocks with the diagonal element stored first, one containing the rest of the original matrix.

Parameters
[in]offsetmagma_int_t size of the first block
[in]bsizemagma_int_t size of the diagonal blocks
[in]Amagma_s_matrix CSR input matrix
[out]Dmagma_s_matrix* CSR matrix containing diagonal blocks
[out]Rmagma_s_matrix* CSR matrix containing rest
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sdiagcheck ( magma_s_matrix  dA,
magma_queue_t  queue 
)

This routine checks for a CSR matrix whether there exists a zero on the diagonal.

This can be the diagonal entry missing or an explicit zero.

Parameters
[in]dAmagma_s_matrix matrix in CSR format
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sdiameter ( magma_s_matrix *  A,
magma_queue_t  queue 
)

Computes the diameter of a sparse matrix and stores the value in diameter.

Parameters
[in,out]Amagma_s_matrix* sparse matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sdomainoverlap ( magma_index_t  num_rows,
magma_int_t *  num_indices,
magma_index_t *  rowptr,
magma_index_t *  colidx,
magma_index_t *  x,
magma_queue_t  queue 
)

Generates the update list.

Parameters
[in]xmagma_index_t* array to sort
[in]num_rowsmagma_int_t number of rows in matrix
[out]num_indicesmagma_int_t* number of indices in array
[in]rowptrmagma_index_t* rowpointer of matrix
[in]colidxmagma_index_t* colindices of matrix
[in]xmagma_index_t* array containing indices for domain overlap
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_seigensolverinfo_init ( magma_s_solver_par *  solver_par,
magma_queue_t  queue 
)

Initializes space for eigensolvers.

Parameters
[in,out]solver_parmagma_s_solver_par* structure containing all solver information
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sfrobenius ( magma_s_matrix  A,
magma_s_matrix  B,
real_Double_t *  res,
magma_queue_t  queue 
)

Computes the Frobenius norm of the difference between the CSR matrices A and B.

They need to share the same sparsity pattern!

Parameters
[in]Amagma_s_matrix sparse matrix in CSR
[in]Bmagma_s_matrix sparse matrix in CSR
[out]resreal_Double_t* Frobenius norm of difference
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sicres ( magma_s_matrix  A,
magma_s_matrix  C,
magma_s_matrix  CT,
magma_s_matrix *  LU,
real_Double_t *  res,
real_Double_t *  nonlinres,
magma_queue_t  queue 
)

Computes the IC residual A - CC^T and returns the difference as well es the Frobenius norm of the difference.

Parameters
[in]Amagma_s_matrix input sparse matrix in CSR
[in]Cmagma_s_matrix input sparse matrix in CSR
[in]CTmagma_s_matrix input sparse matrix in CSR
[in]LUmagma_s_matrix* output sparse matrix in A-LU in CSR
[out]resreal_Double_t* IC residual
[out]nonlinresreal_Double_t* nonlinear residual
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_silures ( magma_s_matrix  A,
magma_s_matrix  L,
magma_s_matrix  U,
magma_s_matrix *  LU,
real_Double_t *  res,
real_Double_t *  nonlinres,
magma_queue_t  queue 
)

Computes the ILU residual A - LU and returns the difference as well es the Frobenius norm of the difference.

Parameters
[in]Amagma_s_matrix input sparse matrix in CSR
[in]Lmagma_s_matrix input sparse matrix in CSR
[in]Umagma_s_matrix input sparse matrix in CSR
[out]LUmagma_s_matrix* output sparse matrix in A-LU in CSR
[out]resreal_Double_t* Frobenius norm of difference
[out]nonlinresreal_Double_t* Frobenius norm of difference
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sindexsort ( magma_index_t *  x,
magma_int_t  first,
magma_int_t  last,
magma_queue_t  queue 
)

Sorts an array of integers in increasing order.

Parameters
[in,out]xmagma_index_t* array to sort
[in]firstmagma_int_t pointer to first element
[in]lastmagma_int_t pointer to last element
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sindexsortval ( magma_index_t *  x,
float *  y,
magma_int_t  first,
magma_int_t  last,
magma_queue_t  queue 
)

Sorts an array of integers, updates a respective array of values.

Parameters
[in,out]xmagma_index_t* array to sort
[in,out]yfloat* array to sort
[in]firstmagma_int_t pointer to first element
[in]lastmagma_int_t pointer to last element
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sinitguess ( magma_s_matrix  A,
magma_s_matrix *  L,
magma_s_matrix *  U,
magma_queue_t  queue 
)

Computes an initial guess for the iterative ILU/IC.

Parameters
[in]Amagma_s_matrix sparse matrix in CSR
[out]Lmagma_s_matrix* sparse matrix in CSR
[out]Umagma_s_matrix* sparse matrix in CSR
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sinitrecursiveLU ( magma_s_matrix  A,
magma_s_matrix *  B,
magma_queue_t  queue 
)

Using the iterative approach of computing ILU factorizations with increasing fill-in, it takes the input matrix A, containing the approximate factors, ( L and U as well ) computes a matrix with one higher level of fill-in, inserts the original approximation as initial guess, and provides the factors L and U also filled with the scaled initial guess.

Parameters
[in]Amagma_s_matrix* sparse matrix in CSR
[out]Bmagma_s_matrix* sparse matrix in CSR
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_slobpcg_res ( magma_int_t  num_rows,
magma_int_t  num_vecs,
magmaFloat_ptr  evalues,
magmaFloat_ptr  X,
magmaFloat_ptr  R,
magmaFloat_ptr  res,
magma_queue_t  queue 
)

This routine computes for Block-LOBPCG, the set of residuals.

R = Ax - x evalues It replaces: for(int i=0; i < n; i++) { magma_saxpy(m, MAGMA_S_MAKE(-evalues[i],0),blockX+i*m,1,blockR+i*m,1); } The memory layout of x is:

/ x1[0] x2[0] x3[0] \
| x1[1] x2[1] x3[1] |

x = | x1[2] x2[2] x3[2] | = x1[0] x1[1] x1[2] x1[3] x1[4] x2[0] x2[1] . | x1[3] x2[3] x3[3] | \ x1[4] x2[4] x3[4] /

Parameters
[in]num_rowsmagma_int_t number of rows
[in]num_vecsmagma_int_t number of vectors
[in]evaluesmagmaFloat_ptr array of eigenvalues/approximations
[in]XmagmaFloat_ptr block of eigenvector approximations
[in]RmagmaFloat_ptr block of residuals
[in]resmagmaFloat_ptr array of residuals
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_slobpcg_shift ( magma_int_t  num_rows,
magma_int_t  num_vecs,
magma_int_t  shift,
magmaFloat_ptr  x,
magma_queue_t  queue 
)

For a Block-LOBPCG, the set of residuals (entries consecutive in memory) shrinks and the vectors are shifted in case shift residuals drop below threshold.

The memory layout of x is:

/ x1[0] x2[0] x3[0] \ | x1[1] x2[1] x3[1] | x = | x1[2] x2[2] x3[2] | = x1[0] x2[0] x3[0] x1[1] x2[1] x3[1] x1[2] . | x1[3] x2[3] x3[3] | \ x1[4] x2[4] x3[4] /

Parameters
[in]num_rowsmagma_int_t number of rows
[in]num_vecsmagma_int_t number of vectors
[in]shiftmagma_int_t shift number
[in,out]xmagmaFloat_ptr input/output vector x
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sm_27stencil ( magma_int_t  n,
magma_s_matrix *  A,
magma_queue_t  queue 
)

Generate a 27-point stencil for a 3D FD discretization.

Parameters
[in]nmagma_int_t number of rows
[out]Amagma_s_matrix* matrix to generate
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sm_5stencil ( magma_int_t  n,
magma_s_matrix *  A,
magma_queue_t  queue 
)

Generate a 5-point stencil for a 2D FD discretization.

Parameters
[in]nmagma_int_t number of rows
[out]Amagma_s_matrix* matrix to generate
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smconjugate ( magma_s_matrix *  A,
magma_queue_t  queue 
)

This function conjugates a matrix.

For a real matrix, no value is changed.

Parameters
[in,out]Amagma_s_matrix* input/output matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smconvert ( magma_s_matrix  A,
magma_s_matrix *  B,
magma_storage_t  old_format,
magma_storage_t  new_format,
magma_queue_t  queue 
)

Converter between different sparse storage formats.

Parameters
[in]Amagma_s_matrix sparse matrix A
[out]Bmagma_s_matrix* copy of A in new format
[in]old_formatmagma_storage_t original storage format
[in]new_formatmagma_storage_t new storage format
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smcsrcompressor ( magma_s_matrix *  A,
magma_queue_t  queue 
)

Removes zeros in a CSR matrix.

Parameters
[in,out]Amagma_s_matrix* input/output matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smcsrcompressor_gpu ( magma_s_matrix *  A,
magma_queue_t  queue 
)

Removes zeros in a CSR matrix.

This is a GPU implementation of the CSR compressor.

Parameters
[in,out]Amagma_s_matrix* input/output matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smdiagadd ( magma_s_matrix *  A,
float  add,
magma_queue_t  queue 
)

Adds a multiple of the Identity matrix to a matrix: A = A+add * I.

Parameters
[in,out]Amagma_s_matrix* input/output matrix
[in]addfloat scaling for the identity matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smdiff ( magma_s_matrix  A,
magma_s_matrix  B,
real_Double_t *  res,
magma_queue_t  queue 
)

Computes the Frobenius norm of the difference between the CSR matrices A and B.

They do not need to share the same sparsity pattern!

   res = ||A-B||_F = sqrt( sum_ij (A_ij-B_ij)^2 )
Parameters
[in]Amagma_s_matrix sparse matrix in CSR
[in]Bmagma_s_matrix sparse matrix in CSR
[out]resreal_Double_t* residual
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smfree ( magma_s_matrix *  A,
magma_queue_t  queue 
)

Free the memory of a magma_s_matrix.

Parameters
[in,out]Amagma_s_matrix* matrix to free
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smgenerator ( magma_int_t  n,
magma_int_t  offdiags,
magma_index_t *  diag_offset,
float *  diag_vals,
magma_s_matrix *  A,
magma_queue_t  queue 
)

Generate a symmetric n x n CSR matrix for a stencil.

Parameters
[in]nmagma_int_t number of rows
[in]offdiagsmagma_int_t number of offdiagonals
[in]diag_offsetmagma_int_t* array containing the offsets
                            (length offsets+1)
[in]diag_valsfloat* array containing the values
                            (length offsets+1)
[out]Amagma_s_matrix* matrix to generate
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smLdiagadd ( magma_s_matrix *  L,
magma_queue_t  queue 
)

Checks for a lower triangular matrix whether it is strictly lower triangular and in the negative case adds a unit diagonal.

It does this in-place.

Parameters
[in,out]Lmagma_s_matrix* sparse matrix in CSR
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smlumerge ( magma_s_matrix  L,
magma_s_matrix  U,
magma_s_matrix *  A,
magma_queue_t  queue 
)

Takes an strictly lower triangular matrix L and an upper triangular matrix U and merges them into a matrix A containing the upper and lower triangular parts.

Parameters
[in]Lmagma_s_matrix input strictly lower triangular matrix L
[in]Umagma_s_matrix input upper triangular matrix U
[out]Amagma_s_matrix* output matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smorderstatistics ( float *  val,
magma_index_t *  col,
magma_index_t *  row,
magma_int_t  length,
magma_int_t  k,
magma_int_t  r,
float *  element,
magma_queue_t  queue 
)

Identifies the kth smallest/largest element in an array and reorders such that these elements come to the front.

The related arrays col and row are also reordered.

Parameters
[in,out]valfloat* Target array, will be modified during operation.
[in,out]colmagma_index_t* Target array, will be modified during operation.
[in,out]rowmagma_index_t* Target array, will be modified during operation.
[in]lengthmagma_int_t Length of the target array.
[in]kmagma_int_t Element to be identified (largest/smallest).
[in]rmagma_int_t rule how to sort: '1' -> largest, '0' -> smallest
[out]elementfloat* location of the respective element
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smscale ( magma_s_matrix *  A,
magma_scale_t  scaling,
magma_queue_t  queue 
)

Scales a matrix.

Parameters
[in,out]Amagma_s_matrix* input/output matrix
[in]scalingmagma_scale_t scaling type (unit rownorm / unit diagonal)
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smshrink ( magma_s_matrix  A,
magma_s_matrix *  B,
magma_queue_t  queue 
)

Shrinks a non-square matrix (m < n) to the smaller dimension.

Parameters
[in]Amagma_s_matrix sparse matrix A
[out]Bmagma_s_matrix* sparse matrix A
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smslice ( magma_int_t  num_slices,
magma_int_t  slice,
magma_s_matrix  A,
magma_s_matrix *  B,
magma_s_matrix *  ALOC,
magma_s_matrix *  ANLOC,
magma_index_t *  comm_i,
float *  comm_v,
magma_int_t *  start,
magma_int_t *  end,
magma_queue_t  queue 
)

Takes a matrix and extracts a slice for solving the system in parallel:

B = A( i:i+n, : ) and ALOC = A(i:i+n,i:i+n) and ANLOCA(0:start - end:n,:)

B is of size n x n, ALOC of size end-start x end-start, ANLOC of size end-start x n

The last slice might be smaller. For the non-local parts, B is the identity. comm contains 1ess in the locations that are non-local but needed to solve local system.

Parameters
[in]num_slicesmagma_int_t number of slices
[in]slicemagma_int_t slice id (0.. num_slices-1)
[in]Amagma_s_matrix sparse matrix in CSR
[out]Bmagma_s_matrix* sparse matrix in CSR
[out]ALOCmagma_s_matrix* sparse matrix in CSR
[out]ANLOCmagma_s_matrix* sparse matrix in CSR
[in,out]comm_imagma_int_t* communication plan
[in,out]comm_vfloat* communication plan
[in]queuemagma_queue_t Queue to execute in.
[out]startmagma_int_t* start of slice (row-index)
[out]endmagma_int_t* end of slice (row-index)
magma_int_t magma_smsort ( float *  x,
magma_index_t *  col,
magma_index_t *  row,
magma_int_t  first,
magma_int_t  last,
magma_queue_t  queue 
)

Sorts an array of values in increasing order.

Parameters
[in,out]xfloat* array to sort
[in,out]colmagma_index_t* Target array, will be modified during operation.
[in,out]rowmagma_index_t* Target array, will be modified during operation.
[in]firstmagma_int_t pointer to first element
[in]lastmagma_int_t pointer to last element
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smtransfer ( magma_s_matrix  A,
magma_s_matrix *  B,
magma_location_t  src,
magma_location_t  dst,
magma_queue_t  queue 
)

Copies a matrix from memory location src to memory location dst.

Parameters
[in]Amagma_s_matrix sparse matrix A
[out]Bmagma_s_matrix* copy of A
[in]srcmagma_location_t original location A
[in]dstmagma_location_t location of the copy of A
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smtranspose ( magma_s_matrix  A,
magma_s_matrix *  B,
magma_queue_t  queue 
)

Interface to cuSPARSE transpose.

Parameters
[in]Amagma_s_matrix input matrix (CSR)
[out]Bmagma_s_matrix* output matrix (CSR)
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_smtransposeconjugate ( magma_s_matrix  A,
magma_s_matrix *  B,
magma_queue_t  queue 
)

This function forms the transpose conjugate of a matrix.

For a real-value matrix, the output is the transpose.

Parameters
[in]Amagma_s_matrix input matrix (CSR)
[out]Bmagma_s_matrix* output matrix (CSR)
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_snonlinres ( magma_s_matrix  A,
magma_s_matrix  L,
magma_s_matrix  U,
magma_s_matrix *  LU,
real_Double_t *  res,
magma_queue_t  queue 
)

Computes the nonlinear residual A - LU and returns the difference as well es the Frobenius norm of the difference.

Parameters
[in]Amagma_s_matrix input sparse matrix in CSR
[in]Lmagma_s_matrix input sparse matrix in CSR
[in]Umagma_s_matrix input sparse matrix in CSR
[out]LUmagma_s_matrix* output sparse matrix in A-LU in CSR
[out]resreal_Double_t* Frobenius norm of difference
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sorderstatistics ( float *  val,
magma_int_t  length,
magma_int_t  k,
magma_int_t  r,
float *  element,
magma_queue_t  queue 
)

Identifies the kth smallest/largest element in an array.

Parameters
[in,out]valfloat* Target array, will be modified during operation.
[in]lengthmagma_int_t Length of the target array.
[in]kmagma_int_t Element to be identified (largest/smallest).
[in]rmagma_int_t rule how to sort: '1' -> largest, '0' -> smallest
[out]elementfloat* location of the respective element
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sparse_opts ( int  argc,
char **  argv,
magma_sopts *  opts,
int *  matrices,
magma_queue_t  queue 
)

Parses input options for a solver.

Parameters
[in]argcint command line input
[in]argvchar** command line input
[in,out]optsmagma_sopts * magma solver options
[out]matricesint counter how many linear systems to process
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sprint_csr ( magma_int_t  n_row,
magma_int_t  n_col,
magma_int_t  nnz,
float **  val,
magma_index_t **  row,
magma_index_t **  col,
magma_queue_t  queue 
)

Prints a CSR matrix in CSR format.

Parameters
[in]n_rowmagma_int_t* number of rows in matrix
[in]n_colmagma_int_t* number of columns in matrix
[in]nnzmagma_int_t* number of nonzeros in matrix
[in]valfloat** value array of CSR
[in]rowmagma_index_t** row pointer of CSR
[in]colmagma_index_t** column indices of CSR
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sprint_csr_mtx ( magma_int_t  n_row,
magma_int_t  n_col,
magma_int_t  nnz,
float **  val,
magma_index_t **  row,
magma_index_t **  col,
magma_order_t  MajorType,
magma_queue_t  queue 
)

Prints a CSR matrix in Matrix Market format.

Parameters
[in]n_rowmagma_int_t* number of rows in matrix
[in]n_colmagma_int_t* number of columns in matrix
[in]nnzmagma_int_t* number of nonzeros in matrix
[in]valfloat** value array of CSR
[in]rowmagma_index_t** row pointer of CSR
[in]colmagma_index_t** column indices of CSR
[in]MajorTypemagma_index_t Row or Column sort default: 0 = RowMajor, 1 = ColMajor
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sprint_matrix ( magma_s_matrix  A,
magma_queue_t  queue 
)

Prints a sparse matrix in CSR format.

Parameters
[in]Amagma_s_matrix sparse matrix in Magma_CSR format
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sprint_vector ( magma_s_matrix  x,
magma_int_t  offset,
magma_int_t  visulen,
magma_queue_t  queue 
)

Visualizes part of a vector of type magma_s_matrix.

With input vector x , offset, visulen, the entries offset - (offset + visulen) of x are visualized.

Parameters
[in]xmagma_s_matrix vector to visualize
[in]offsetmagma_int_t start inex of visualization
[in]visulenmagma_int_t number of entries to visualize
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sresidual ( magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix  x,
float *  res,
magma_queue_t  queue 
)

Computes the residual ||b-Ax|| for a solution approximation x.

Parameters
[in]Amagma_s_matrix input matrix A
[in]bmagma_s_matrix RHS b
[in]xmagma_s_matrix solution approximation
[out]resfloat* return residual
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sresidual_slice ( magma_int_t  start,
magma_int_t  end,
magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix  x,
float *  res,
magma_queue_t  queue 
)

Computes the residual r=||b-Ax|| for the slice r(start:end) for a solution approximation x.

Parameters
[in]startmagma_int_t start of slice (row-index)
[in]endmagma_int_t end of slice (row-index)
[in]Amagma_s_matrix input matrix A
[in]bmagma_s_matrix RHS b
[in]xmagma_s_matrix solution approximation
[out]resfloat* return residual
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_sresidualvec ( magma_s_matrix  A,
magma_s_matrix  b,
magma_s_matrix  x,
magma_s_matrix *  r,
float *  res,
magma_queue_t  queue 
)

Computes the residual r = b-Ax for a solution approximation x.

It returns both, the actual residual and the residual vector

Parameters
[in]Amagma_s_matrix input matrix A
[in]bmagma_s_matrix RHS b
[in]xmagma_s_matrix solution approximation
[in,out]rmagma_s_matrix* residual vector
[out]resfloat* return residual
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_srowentries ( magma_s_matrix *  A,
magma_queue_t  queue 
)

Checks the maximal number of nonzeros in a row of matrix A.

Inserts the data into max_nnz_row.

Parameters
[in,out]Amagma_s_matrix* sparse matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_ssolverinfo ( magma_s_solver_par *  solver_par,
magma_s_preconditioner *  precond_par,
magma_queue_t  queue 
)

Prints information about a previously called solver.

Parameters
[in]solver_parmagma_s_solver_par* structure containing all solver information
[in,out]precond_parmagma_s_preconditioner* structure containing all preconditioner information
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_ssolverinfo_free ( magma_s_solver_par *  solver_par,
magma_s_preconditioner *  precond_par,
magma_queue_t  queue 
)

Frees any memory assocoiated with the verbose mode of solver_par.

The other values are set to default.

Parameters
[in,out]solver_parmagma_s_solver_par* structure containing all solver information
[in,out]precond_parmagma_s_preconditioner* structure containing all preconditioner information
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_ssolverinfo_init ( magma_s_solver_par *  solver_par,
magma_s_preconditioner *  precond_par,
magma_queue_t  queue 
)

Initializes all solver and preconditioner parameters.

Parameters
[in,out]solver_parmagma_s_solver_par* structure containing all solver information
[in,out]precond_parmagma_s_preconditioner* structure containing all preconditioner information
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_ssort ( float *  x,
magma_int_t  first,
magma_int_t  last,
magma_queue_t  queue 
)

Sorts an array of values in increasing order.

Parameters
[in,out]xfloat* array to sort
[in]firstmagma_int_t pointer to first element
[in]lastmagma_int_t pointer to last element
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_ssymbilu ( magma_s_matrix *  A,
magma_int_t  levels,
magma_s_matrix *  L,
magma_s_matrix *  U,
magma_queue_t  queue 
)

This routine performs a symbolic ILU factorization.

The algorithm is taken from an implementation written by Edmond Chow.

Parameters
[in,out]Amagma_s_matrix* matrix in magma sparse matrix format containing the original matrix on input, and L,U on output
[in]levelsmagma_magma_int_t_t fill in level
[out]Lmagma_s_matrix* output lower triangular matrix in magma sparse matrix format empty on function call
[out]Umagma_s_matrix* output upper triangular matrix in magma sparse matrix format empty on function call
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svget ( magma_s_matrix  v,
magma_int_t *  m,
magma_int_t *  n,
float **  val,
magma_queue_t  queue 
)

Passes a MAGMA vector back.

Parameters
[in]vmagma_s_matrix magma vector
[out]mmagma_int_t number of rows
[out]nmagma_int_t number of columns
[out]valfloat* array containing vector entries
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svget_dev ( magma_s_matrix  v,
magma_int_t *  m,
magma_int_t *  n,
magmaFloat_ptr *  val,
magma_queue_t  queue 
)

Passes a MAGMA vector back (located on DEV).

Parameters
[in]vmagma_s_matrix magma vector
[out]mmagma_int_t number of rows
[out]nmagma_int_t number of columns
[out]valmagmaFloat_ptr array containing vector entries
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svinit ( magma_s_matrix *  x,
magma_location_t  mem_loc,
magma_int_t  num_rows,
magma_int_t  num_cols,
float  values,
magma_queue_t  queue 
)

Allocates memory for magma_s_matrix and initializes it with the passed value.

Parameters
[out]xmagma_s_matrix* vector to initialize
[in]mem_locmagma_location_t memory for vector
[in]num_rowsmagma_int_t desired length of vector
[in]num_colsmagma_int_t desired width of vector-block (columns of dense matrix)
[in]valuesfloat entries in vector
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svread ( magma_s_matrix *  x,
magma_int_t  length,
char *  filename,
magma_queue_t  queue 
)

Reads in a float vector of length "length".

Parameters
[out]xmagma_s_matrix * vector to read in
[in]lengthmagma_int_t length of vector
[in]filenamechar* file where vector is stored
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svset ( magma_int_t  m,
magma_int_t  n,
float *  val,
magma_s_matrix *  v,
magma_queue_t  queue 
)

Passes a vector to MAGMA.

Parameters
[in]mmagma_int_t number of rows
[in]nmagma_int_t number of columns
[in]valfloat* array containing vector entries
[out]vmagma_s_matrix* magma vector
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svset_dev ( magma_int_t  m,
magma_int_t  n,
magmaFloat_ptr  val,
magma_s_matrix *  v,
magma_queue_t  queue 
)

Passes a vector to MAGMA (located on DEV).

Parameters
[in]mmagma_int_t number of rows
[in]nmagma_int_t number of columns
[in]valmagmaFloat_ptr array containing vector entries
[out]vmagma_s_matrix* magma vector
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svspread ( magma_s_matrix *  x,
const char *  filename,
magma_queue_t  queue 
)

Reads in a sparse vector-block stored in COO format.

Parameters
[out]xmagma_s_matrix * vector to read in
[in]filenamechar* file where vector is stored
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_svtranspose ( magma_s_matrix  x,
magma_s_matrix *  y,
magma_queue_t  queue 
)

Transposes a vector from col to row major and vice versa.

Parameters
[in]xmagma_s_matrix input vector
[out]ymagma_s_matrix* output vector
[in]queuemagma_queue_t Queue to execute in.
magma_int_t magma_swrite_csr_mtx ( magma_s_matrix  A,
magma_order_t  MajorType,
const char *  filename,
magma_queue_t  queue 
)

Writes a CSR matrix to a file using Matrix Market format.

Parameters
[in]Amagma_s_matrix matrix to write out
[in]MajorTypemagma_index_t Row or Column sort default: 0 = RowMajor, 1 = ColMajor TODO: use named constants (e.g., MagmaRowMajor), not numbers.
[in]filenameconst char* output-filname of the mtx matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t read_s_csr_from_mtx ( magma_storage_t *  type,
magma_location_t *  location,
magma_int_t *  n_row,
magma_int_t *  n_col,
magma_int_t *  nnz,
float **  val,
magma_index_t **  row,
magma_index_t **  col,
const char *  filename,
magma_queue_t  queue 
)

Reads in a matrix stored in coo format from a Matrix Market (.mtx) file and converts it into CSR format.

It duplicates the off-diagonal entries in the symmetric case.

Parameters
[out]typemagma_storage_t* storage type of matrix
[out]locationmagma_location_t* location of matrix
[out]n_rowmagma_int_t* number of rows in matrix
[out]n_colmagma_int_t* number of columns in matrix
[out]nnzmagma_int_t* number of nonzeros in matrix
[out]valfloat** value array of CSR output
[out]rowmagma_index_t** row pointer of CSR output
[out]colmagma_index_t** column indices of CSR output
[in]filenameconst char* filname of the mtx matrix
[in]queuemagma_queue_t Queue to execute in.
magma_int_t s_transpose_csr ( magma_int_t  n_rows,
magma_int_t  n_cols,
magma_int_t  nnz,
float *  values,
magma_index_t *  rowptr,
magma_index_t *  colind,
magma_int_t *  new_n_rows,
magma_int_t *  new_n_cols,
magma_int_t *  new_nnz,
float **  new_values,
magma_index_t **  new_rowptr,
magma_index_t **  new_colind,
magma_queue_t  queue 
)

Transposes a matrix stored in CSR format on the CPU host.

Parameters
[in]n_rowsmagma_int_t number of rows in input matrix
[in]n_colsmagma_int_t number of columns in input matrix
[in]nnzmagma_int_t number of nonzeros in input matrix
[in]valuesfloat* value array of input matrix
[in]rowptrmagma_index_t* row pointer of input matrix
[in]colindmagma_index_t* column indices of input matrix
[in]new_n_rowsmagma_index_t* number of rows in transposed matrix
[in]new_n_colsmagma_index_t* number of columns in transposed matrix
[in]new_nnzmagma_index_t* number of nonzeros in transposed matrix
[in]new_valuesfloat** value array of transposed matrix
[in]new_rowptrmagma_index_t** row pointer of transposed matrix
[in]new_colindmagma_index_t** column indices of transposed matrix
[in]queuemagma_queue_t Queue to execute in.