Loading...
Searching...
No Matches
single precision
Sparse LA » Sparse auxiliary

## 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.
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.
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.
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.
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.
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)
| This is an interface that allows to use any iterative solver on the linear system Ax = b.
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.
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.
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.
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.
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.
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.
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.
magma_int_t | magma_smfree (magma_s_matrix *A, magma_queue_t queue)
| Free the memory of a magma_s_matrix.
magma_int_t | magma_sprecondfree (magma_s_preconditioner *precond_par, magma_queue_t queue)
| Free a preconditioner.
magma_int_t | magma_smprepare_batched (magma_uplo_t uplotype, magma_trans_t transtype, magma_diag_t diagtype, magma_s_matrix L, magma_s_matrix LC, magma_index_t *sizes, magma_index_t *locations, float *trisystems, float *rhs, magma_queue_t queue)
| Takes a sparse matrix and generates an array containing the sizes of the different systems an array containing the indices with the locations in the sparse matrix where the data comes from and goes back to an array containing all the sparse triangular systems.
magma_int_t | magma_smtrisolve_batched (magma_uplo_t uplotype, magma_trans_t transtype, magma_diag_t diagtype, magma_s_matrix L, magma_s_matrix LC, magma_index_t *sizes, magma_index_t *locations, float *trisystems, float *rhs, magma_queue_t queue)
| Does all triangular solves.
magma_int_t | magma_smbackinsert_batched (magma_uplo_t uplotype, magma_trans_t transtype, magma_diag_t diagtype, magma_s_matrix *M, magma_index_t *sizes, magma_index_t *locations, float *trisystems, float *rhs, magma_queue_t queue)
| Inserts the values into the preconditioner matrix.
magma_int_t | magma_smiluspai_sizecheck (magma_s_matrix A, magma_index_t batchsize, magma_index_t *maxsize, magma_queue_t queue)
| Checks for a matrix whether the batched ISAI works for a given thread-block size.
magma_int_t | magma_smisai_blockstruct (magma_int_t n, magma_int_t bs, magma_int_t offs, magma_uplo_t uplotype, magma_s_matrix *A, magma_queue_t queue)
| Generates a block-diagonal sparsity pattern with block-size bs.
magma_int_t | magma_smatrix_cup (magma_s_matrix A, magma_s_matrix B, magma_s_matrix *U, magma_queue_t queue)
| Generates a matrix \(U = A \cup B\).
magma_int_t | magma_smatrix_cap (magma_s_matrix A, magma_s_matrix B, magma_s_matrix *U, magma_queue_t queue)
| Generates a matrix with entries being in both matrices: \(U = A \cap B\).
magma_int_t | magma_smatrix_negcap (magma_s_matrix A, magma_s_matrix B, magma_s_matrix *U, magma_queue_t queue)
| Generates a list of matrix entries being part of A but not of B.
magma_int_t | magma_smatrix_tril_negcap (magma_s_matrix A, magma_s_matrix B, magma_s_matrix *U, magma_queue_t queue)
| Generates a list of matrix entries being part of tril(A) but not of B.
magma_int_t | magma_smatrix_triu_negcap (magma_s_matrix A, magma_s_matrix B, magma_s_matrix *U, magma_queue_t queue)
| Generates a matrix with entries being part of triu(A) but not of B.
magma_int_t | magma_smatrix_addrowindex (magma_s_matrix *A, magma_queue_t queue)
| Adds to a CSR matrix an array containing the rowindexes.
magma_int_t | magma_scsrcoo_transpose (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Transposes a matrix that already contains rowidx.
magma_int_t | magma_smatrix_createrowptr (magma_int_t n, magma_index_t *row, magma_queue_t queue)
| This function generates a rowpointer out of a row-wise element count in parallel.
magma_int_t | magma_smatrix_swap (magma_s_matrix *A, magma_s_matrix *B, magma_queue_t queue)
| Swaps two matrices.
magma_int_t | magma_smatrix_tril (magma_s_matrix A, magma_s_matrix *L, magma_queue_t queue)
| Extracts the lower triangular of a matrix: L = tril(A).
magma_int_t | magma_smatrix_triu (magma_s_matrix A, magma_s_matrix *U, magma_queue_t queue)
| Extracts the lower triangular of a matrix: U = triu(A).
magma_int_t | magma_smatrix_abssum (magma_s_matrix A, float *sum, magma_queue_t queue)
| Computes the sum of the absolute values in a matrix.
magma_int_t | magma_scsr_sort (magma_s_matrix *A, magma_queue_t queue)
| SOrts the elements in a CSR matrix for increasing column index.
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.
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.
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.
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.
magma_int_t | magma_smcsrcompressor (magma_s_matrix *A, magma_queue_t queue)
| Removes zeros in a CSR matrix.
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.
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.
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).
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).
magma_int_t | magma_smdiagdom (magma_s_matrix M, float *min_dd, float *max_dd, float *avg_dd, magma_queue_t queue)
| This routine takes a CSR matrix and computes the average diagonal dominance.
magma_int_t | magma_smbdiagdom (magma_s_matrix M, magma_s_matrix blocksizes, float *min_dd, float *max_dd, float *avg_dd, magma_queue_t queue)
| This routine takes a CSR matrix and computes the average block-diagonal dominance.
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.
magma_int_t | magma_smfrobenius (magma_s_matrix A, magma_s_matrix B, magma_s_matrix S, float *norm, magma_queue_t queue)
| Computes the Frobenius norm || A - B ||_S on the sparsity pattern of S.
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.
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.
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.
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.
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.
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.
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.
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.
magma_int_t | magma_sprint_matrix (magma_s_matrix A, magma_queue_t queue)
| Prints a sparse matrix in CSR format.
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.
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.
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.
magma_int_t | magma_smscale (magma_s_matrix *A, magma_scale_t scaling, magma_queue_t queue)
| Scales a matrix.
magma_int_t | magma_smscale_matrix_rhs (magma_s_matrix *A, magma_s_matrix *b, magma_s_matrix *scaling_factors, magma_scale_t scaling, magma_queue_t queue)
| Scales a matrix and a right hand side vector of a Ax = b system.
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.
magma_int_t | magma_smscale_generate (magma_int_t n, magma_scale_t *scaling, magma_side_t *side, magma_s_matrix *A, magma_s_matrix *scaling_factors, magma_queue_t queue)
| Generates n vectors of scaling factors from the A matrix and stores them in the factors matrix as column vectors in column major ordering.
magma_int_t | magma_smscale_apply (magma_int_t n, magma_side_t *side, magma_s_matrix *scaling_factors, magma_s_matrix *A, magma_queue_t queue)
| Applies n diagonal scaling matrices to a matrix A; n=[1,2], factor[i] is applied to side[i] of the matrix.
magma_int_t | magma_sdimv (magma_s_matrix *vecA, magma_s_matrix *vecB, magma_queue_t queue)
| Multiplies a diagonal matrix (vecA) and a vector (vecB).
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.
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:
magma_int_t | magma_smsupernodal (magma_int_t *max_bs, magma_s_matrix A, magma_s_matrix *S, magma_queue_t queue)
| Generates a block-diagonal sparsity pattern with block-size bs.
magma_int_t | magma_smvarsizeblockstruct (magma_int_t n, magma_int_t *bs, magma_int_t bsl, magma_uplo_t uplotype, magma_s_matrix *A, magma_queue_t queue)
| Generates a block-diagonal sparsity pattern with variable block-size.
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.
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.
magma_int_t | magma_smtranspose (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Interface to cuSPARSE transpose.
magma_int_t | magma_s_cucsrtranspose (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Helper function to transpose CSR matrix.
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.
magma_int_t | magma_smtranspose_cpu (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Generates a transpose of A on the CPU.
magma_int_t | magma_smtransposeconj_cpu (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Generates a transpose conjugate of A on the CPU.
magma_int_t | magma_smtransposestruct_cpu (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Generates a transpose of the nonzero pattern of A on the CPU.
magma_int_t | magma_smtransposeabs_cpu (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Generates a transpose with absolute values of A on the CPU.
magma_int_t | magma_sparic_sweep (magma_s_matrix A, magma_s_matrix *L, magma_queue_t queue)
| This function does one asynchronous ParILU sweep (symmetric case).
magma_int_t | magma_sparic_sweep_sync (magma_s_matrix A, magma_s_matrix *L, magma_queue_t queue)
| This function does one synchronized ParILU sweep (symmetric case).
magma_int_t | magma_sparict_candidates (magma_s_matrix L0, magma_s_matrix L, magma_s_matrix LT, magma_s_matrix *L_new, magma_queue_t queue)
| This function identifies the candidates like they appear as ILU1 fill-in.
magma_int_t | magma_sparict_sweep_sync (magma_s_matrix *A, magma_s_matrix *L, magma_queue_t queue)
| This function does one synchronized ParILU sweep.
magma_int_t | magma_sparilu_sweep (magma_s_matrix A, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
| This function does one asynchronous ParILU sweep.
magma_int_t | magma_sparilu_sweep_sync (magma_s_matrix A, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
| This function does one synchronized ParILU sweep.
magma_int_t | magma_sparilut_sweep (magma_s_matrix *A, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
| This function does an ParILUT sweep.
magma_int_t | magma_sparilut_sweep_sync (magma_s_matrix *A, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
| This function does an ParILUT sweep.
magma_int_t | magma_sparilut_residuals (magma_s_matrix A, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *R, magma_queue_t queue)
| This function computes the ILU residual in the locations included in the sparsity pattern of R.
magma_int_t | magma_sparilut_thrsrm (magma_int_t order, magma_s_matrix *A, float *thrs, magma_queue_t queue)
| Removes any element with absolute value smaller equal or larger equal thrs from the matrix and compacts the whole thing.
magma_int_t | magma_sparilut_thrsrm_U (magma_int_t order, magma_s_matrix L, magma_s_matrix *A, float *thrs, magma_queue_t queue)
| Removes any element with absolute value smaller equal or larger equal thrs from the matrix and compacts the whole thing.
magma_int_t | magma_sparilut_rmselected (magma_s_matrix R, magma_s_matrix *A, magma_queue_t queue)
| Removes a selected list of elements from the matrix.
magma_int_t | magma_sparilut_selectoneperrow (magma_int_t order, magma_s_matrix *A, magma_s_matrix *oneA, magma_queue_t queue)
| This function takes a list of candidates with residuals, and selects the largest in every row.
magma_int_t | magma_sparilut_selecttwoperrow (magma_int_t order, magma_s_matrix *A, magma_s_matrix *oneA, magma_queue_t queue)
| This function takes a list of candidates with residuals, and selects the largest in every row.
magma_int_t | magma_sparilut_selectoneperrowthrs_lower (magma_s_matrix L, magma_s_matrix U, magma_s_matrix *A, float rtol, magma_s_matrix *oneA, magma_queue_t queue)
| This function takes a list of candidates with residuals, and selects the largest in every row.
magma_int_t | magma_sparilut_selectoneperrowthrs_upper (magma_s_matrix L, magma_s_matrix U, magma_s_matrix *A, float rtol, magma_s_matrix *oneA, magma_queue_t queue)
| This function takes a list of candidates with residuals, and selects the largest in every row.
magma_int_t | magma_sparilut_preselect (magma_int_t order, magma_s_matrix *A, magma_s_matrix *oneA, magma_queue_t queue)
| This function takes a list of candidates with residuals, and selects the largest in every row.
magma_int_t | magma_sparilut_preselect_scale (magma_s_matrix *L, magma_s_matrix *oneL, magma_s_matrix *U, magma_s_matrix *oneU, magma_queue_t queue)
| This function takes a list of candidates with residuals, and selects the largest in every row.
magma_int_t | magma_sparilut_transpose (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| Transposes a matrix that already contains rowidx.
magma_int_t | magma_sparilut_transpose_select_one (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| This is a special routine with very limited scope.
magma_int_t | magma_sparilut_create_collinkedlist (magma_s_matrix A, magma_s_matrix *B, magma_queue_t queue)
| For the matrix U in CSR (row-major) this creates B containing a row-ptr to the columns and a linked list for the elements.
magma_int_t | magma_sparilut_sweep_semilinked (magma_s_matrix *A, magma_s_matrix *L, magma_s_matrix *US, magma_queue_t queue)
| This function does an ParILU sweep.
magma_int_t | magma_sparilut_sweep_list (magma_s_matrix *A, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
| This function does an ParILU sweep.
magma_int_t | magma_sparilut_residuals_semilinked (magma_s_matrix A, magma_s_matrix L, magma_s_matrix US, magma_s_matrix *L_new, magma_queue_t queue)
| This function computes the residuals.
magma_int_t | magma_sparilut_residuals_transpose (magma_s_matrix A, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *U_new, magma_queue_t queue)
| This function computes the residuals.
magma_int_t | magma_sparilut_residuals_list (magma_s_matrix A, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *L_new, magma_queue_t queue)
| This function computes the residuals.
magma_int_t | magma_sparilut_sweep_linkedlist (magma_s_matrix *A, magma_s_matrix *L, magma_s_matrix *U, magma_queue_t queue)
| This function does an ParILU sweep.
magma_int_t | magma_sparilut_residuals_linkedlist (magma_s_matrix A, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *L_new, magma_queue_t queue)
| This function computes the residuals.
magma_int_t | magma_sparilut_colmajor (magma_s_matrix A, magma_s_matrix *AC, magma_queue_t queue)
| This function creates a col-pointer and a linked list along the columns for a row-major CSR matrix.
magma_int_t | magma_sparilut_reorder (magma_s_matrix *LU, magma_queue_t queue)
| This routine reorders the matrix (inplace) for easier access.
magma_int_t | magma_sparilut_colmajorup (magma_s_matrix A, magma_s_matrix *AC, magma_queue_t queue)
| This function creates a col-pointer and a linked list along the columns for a row-major CSR matrix.
magma_int_t | magma_sparilut_insert (magma_int_t *num_rmL, magma_int_t *num_rmU, magma_index_t *rm_locL, magma_index_t *rm_locU, magma_s_matrix *L_new, magma_s_matrix *U_new, magma_s_matrix *L, magma_s_matrix *U, magma_s_matrix *UR, magma_queue_t queue)
| Inserts for the iterative dynamic ILU an new element in the (empty) place.
magma_int_t | magma_sparilut_candidates (magma_s_matrix L0, magma_s_matrix U0, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *L_new, magma_s_matrix *U_new, magma_queue_t queue)
| This function identifies the candidates like they appear as ILU1 fill-in.
magma_int_t | magma_sparilut_candidates_semilinked (magma_s_matrix L0, magma_s_matrix U0, magma_s_matrix L, magma_s_matrix U, magma_s_matrix UT, magma_s_matrix *L_new, magma_s_matrix *U_new, magma_queue_t queue)
| This function identifies the candidates like they appear as ILU1 fill-in.
magma_int_t | magma_sparilut_rm_thrs (float *thrs, magma_int_t *num_rm, magma_s_matrix *LU, magma_s_matrix *LU_new, magma_index_t *rm_loc, magma_queue_t queue)
| This routine removes matrix entries from the structure that are smaller than the threshold.
magma_int_t | magma_sparilut_count (magma_s_matrix L, magma_int_t *num, magma_queue_t queue)
| This is a helper routine counting elements in a matrix in unordered Magma_CSRLIST format.
magma_int_t | magma_sparilut_select_candidates_L (magma_int_t *num_rm, magma_index_t *rm_loc, magma_s_matrix *L_new, magma_queue_t queue)
| Screens the new candidates for multiple elements in the same row.
magma_int_t | magma_sparilut_select_candidates_U (magma_int_t *num_rm, magma_index_t *rm_loc, magma_s_matrix *L_new, magma_queue_t queue)
| Screens the new candidates for multiple elements in the same row.
magma_int_t | magma_sparilut_set_approx_thrs (magma_int_t num_rm, magma_s_matrix *LU, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine approximates the threshold for removing num_rm elements.
magma_int_t | magma_sparilut_set_thrs_randomselect (magma_int_t num_rm, magma_s_matrix *LU, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine approximates the threshold for removing num_rm elements.
magma_int_t | magma_sparilut_set_thrs_L_scaled (magma_int_t num_rm, magma_s_matrix *L, magma_s_matrix *U, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine approximates the threshold for removing num_rm elements.
magma_int_t | magma_sparilut_set_thrs_randomselect_approx2 (magma_int_t num_rm, magma_s_matrix *LU, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine approximates the threshold for removing num_rm elements.
magma_int_t | magma_sparilut_set_thrs_randomselect_approx (magma_int_t num_rm, magma_s_matrix *LU, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine approximates the threshold for removing num_rm elements.
magma_int_t | magma_sparilut_set_thrs_randomselect_factors (magma_int_t num_rm, magma_s_matrix *L, magma_s_matrix *U, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine approximates the threshold for removing num_rm elements.
magma_int_t | magma_sparilut_set_exact_thrs (magma_int_t num_rm, magma_s_matrix *LU, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine provides the exact threshold for removing num_rm elements.
magma_int_t | magma_sparilut_set_approx_thrs_inc (magma_int_t num_rm, magma_s_matrix *LU, magma_int_t order, float *thrs, magma_queue_t queue)
| This routine provides the exact threshold for removing num_rm elements.
magma_int_t | magma_sparilut_align_residuals (magma_s_matrix L, magma_s_matrix U, magma_s_matrix *Lnew, magma_s_matrix *Unew, magma_queue_t queue)
| This function scales the residuals of a lower triangular factor L with the diagonal of U.
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.
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.
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.
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.
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 ParILU/ParIC.
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.
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.
magma_int_t | magma_sselect (float *a, magma_int_t size, magma_int_t k, magma_queue_t queue)
| An efficient implementation of Blum, Floyd, Pratt, Rivest, and Tarjan's worst-case linear selection algorithm.
magma_int_t | magma_sselectrandom (float *a, magma_int_t size, magma_int_t k, magma_queue_t queue)
| An efficient implementation of Blum, Floyd, Pratt, Rivest, and Tarjan's worst-case linear selection algorithm.
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.
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.
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.
magma_int_t | magma_seigensolverinfo_init (magma_s_solver_par *solver_par, magma_queue_t queue)
| Initializes space for eigensolvers.
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.
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.
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.
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.
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.
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.
magma_int_t | magma_sorderstatistics_inc (float *val, magma_int_t length, magma_int_t k, magma_int_t inc, magma_int_t r, float *element, magma_queue_t queue)
| Approximates the k-th smallest element in an array by using order-statistics with step-size inc.
magma_int_t | magma_sbitonic_sort (magma_int_t start, magma_int_t length, float *seq, magma_int_t flag, magma_queue_t queue)
| Approximates the k-th smallest element in an array by using order-statistics with step-size inc.
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.
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.
magma_int_t | magma_svinit_rand (magma_s_matrix *x, magma_location_t mem_loc, magma_int_t num_rows, magma_int_t num_cols, magma_queue_t queue)
| Allocates memory for magma_s_matrix and initializes it with random values.
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.
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".
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.
magma_int_t | magma_swrite_vector (magma_s_matrix A, const char *filename, magma_queue_t queue)
| Writes a vector to a file.
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.
magma_int_t | magma_svcopy (magma_s_matrix v, magma_int_t *m, magma_int_t *n, float *val, magma_queue_t queue)
| Passes a MAGMA vector back.
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).
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.
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).
magma_int_t | magma_svcopy_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).
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.
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.
magma_int_t | magma_smatrix_cup_gpu (magma_s_matrix A, magma_s_matrix B, magma_s_matrix *U, magma_queue_t queue)
| Generates a matrix \(U = A \cup B\).
magma_int_t | magma_scsr_sort_gpu (magma_s_matrix *A, magma_queue_t queue)
| Generates a matrix \(U = A \cup B\).
magma_int_t | magma_smconjugate (magma_s_matrix *A, magma_queue_t queue)
| This function conjugates a matrix.
magma_int_t | magma_smcsrcompressor_gpu (magma_s_matrix *A, magma_queue_t queue)
| Removes zeros in a CSR matrix.
magma_int_t | magma_spreselect_gpu (magma_int_t order, magma_s_matrix *A, magma_s_matrix *oneA, magma_queue_t queue)
| This function takes a list of candidates with residuals, and selects the largest in every row.
magma_int_t | magma_ssampleselect (magma_int_t total_size, magma_int_t subset_size, float *val, float *thrs, magma_ptr *tmp_ptr, magma_int_t *tmp_size, magma_queue_t queue)
| This routine selects a threshold separating the subset_size smallest magnitude elements from the rest.
magma_int_t | magma_ssampleselect_approx (magma_int_t total_size, magma_int_t subset_size, float *val, float *thrs, magma_ptr *tmp_ptr, magma_int_t *tmp_size, magma_queue_t queue)
| This routine selects an approximate threshold separating the subset_size smallest magnitude elements from the rest.
magma_int_t | magma_ssampleselect_nodp (magma_int_t total_size, magma_int_t subset_size, float *val, float *thrs, magma_ptr *tmp_ptr, magma_int_t *tmp_size, magma_queue_t queue)
| This routine selects a threshold separating the subset_size smallest magnitude elements from the rest.
magma_int_t | magma_ssampleselect_approx_nodp (magma_int_t total_size, magma_int_t subset_size, float *val, float *thrs, magma_ptr *tmp_ptr, magma_int_t *tmp_size, magma_queue_t queue)
| This routine selects an approximate threshold separating the subset_size smallest magnitude elements from the rest.
magma_int_t | magma_sisai_generator_regs (magma_uplo_t uplotype, magma_trans_t transtype, magma_diag_t diagtype, magma_s_matrix L, magma_s_matrix *M, magma_queue_t queue)
| This routine is designet to combine all kernels into one.
magma_int_t | magma_sgeisai_maxblock (magma_s_matrix L, magma_s_matrix *MT, magma_queue_t queue)
| This routine maximizes the pattern for the ISAI preconditioner.
magma_int_t | magma_smtrisolve_batched_gpu (magma_uplo_t uplotype, magma_trans_t transtype, magma_diag_t diagtype, magma_s_matrix L, magma_s_matrix LC, magma_index_t *sizes, magma_index_t *locations, float *trisystems, float *rhs, magma_queue_t queue)
| Does all triangular solves.
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.
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.
magma_int_t | magma_sparilut_candidates_gpu (magma_s_matrix L0, magma_s_matrix U0, magma_s_matrix L, magma_s_matrix U, magma_s_matrix *L_new, magma_s_matrix *U_new, magma_queue_t queue)
| This function identifies the locations with a potential nonzero ILU residual R = A - L*U where L and U are the current incomplete factors.
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.

## Variables

US | val
| Removes any element with absolute value smaller thrs from the matrix.

## Detailed Description

## Function Documentation

## magma_s_precond()

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] | A | magma_s_matrix sparse matrix A
  [in] | b | magma_s_matrix input vector b
  [in] | x | magma_s_matrix* output vector x
  [in,out] | precond | magma_s_preconditioner preconditioner
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_precondsetup()

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] | A | magma_s_matrix sparse matrix M
  [in] | b | magma_s_matrix input vector y
  [in] | solver | magma_s_solver_par solver structure using the preconditioner
  [in,out] | precond | magma_s_preconditioner preconditioner
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_applyprecond()

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] | A | magma_s_matrix sparse matrix A
  [in] | b | magma_s_matrix input vector b
  [in,out] | x | magma_s_matrix* output vector x
  [in] | precond | magma_s_preconditioner preconditioner
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_applyprecond_left()

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] | trans | magma_trans_t mode of the preconditioner: MagmaTrans or MagmaNoTrans
  [in] | A | magma_s_matrix sparse matrix A
  [in] | b | magma_s_matrix input vector b
  [in,out] | x | magma_s_matrix* output vector x
  [in] | precond | magma_s_preconditioner preconditioner
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_applyprecond_right()

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] | trans | magma_trans_t mode of the preconditioner: MagmaTrans or MagmaNoTrans
  [in] | A | magma_s_matrix sparse matrix A
  [in] | b | magma_s_matrix input vector b
  [in,out] | x | magma_s_matrix* output vector x
  [in] | precond | magma_s_preconditioner preconditioner
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_solver()

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 )

This is an interface that allows to use any iterative solver on the linear system Ax = b.

All linear algebra objects are expected to be on the device, the linear algebra objects are MAGMA-sparse specific structures (dense matrix b, dense matrix x, sparse/dense matrix A). The additional parameter zopts contains information about the solver and the preconditioner. the type of solver the relative / absolute stopping criterion the maximum number of iterations the preconditioner type ... Please see magmasparse_types.h for details about the fields and magma_sutil_sparse.cpp for the possible options.

Parameters

  [in] | A | magma_s_matrix sparse matrix A
  [in] | b | magma_s_matrix input vector b
  [in] | x | magma_s_matrix* output vector x
  [in] | zopts | magma_sopts options for solver and preconditioner
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sapplycustomprecond_l()

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] | b | magma_s_matrix RHS
  [in,out] | x | magma_s_matrix* vector to precondition
  [in,out] | precond | magma_s_preconditioner* preconditioner parameters
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sapplycustomprecond_r()

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] | b | magma_s_matrix RHS
  [in,out] | x | magma_s_matrix* vector to precondition
  [in,out] | precond | magma_s_preconditioner* preconditioner parameters
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sresidual()

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] | A | magma_s_matrix input matrix A
  [in] | b | magma_s_matrix RHS b
  [in] | x | magma_s_matrix solution approximation
  [out] | res | float* return residual
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sresidual_slice()

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] | start | magma_int_t start of slice (row-index)
  [in] | end | magma_int_t end of slice (row-index)
  [in] | A | magma_s_matrix input matrix A
  [in] | b | magma_s_matrix RHS b
  [in] | x | magma_s_matrix solution approximation
  [out] | res | float* return residual
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sresidualvec()

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] | A | magma_s_matrix input matrix A
  [in] | b | magma_s_matrix RHS b
  [in] | x | magma_s_matrix solution approximation
  [in,out] | r | magma_s_matrix* residual vector
  [out] | res | float* return residual
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsrsplit()

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] | offset | magma_int_t size of the first block
  [in] | bsize | magma_int_t size of the diagonal blocks
  [in] | A | magma_s_matrix CSR input matrix
  [out] | D | magma_s_matrix* CSR matrix containing diagonal blocks
  [out] | R | magma_s_matrix* CSR matrix containing rest
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sdomainoverlap()

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] | x | magma_index_t* array to sort
  [in] | num_rows | magma_int_t number of rows in matrix
  [out] | num_indices | magma_int_t* number of indices in array
  [in] | rowptr | magma_index_t* rowpointer of matrix
  [in] | colidx | magma_index_t* colindices of matrix
  [in] | x | magma_index_t* array containing indices for domain overlap
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smfree()

magma_int_t magma_smfree | ( | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Free the memory of a magma_s_matrix.

Note, this routine performs a magma_queue_sync on the queue passed to it prior to freeing any memory.

Parameters

  [in,out] | A | magma_s_matrix* matrix to free
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sprecondfree()

magma_int_t magma_sprecondfree | ( | magma_s_preconditioner * | precond_par,
|  | magma_queue_t | queue )

Free a preconditioner.

Note, this routine performs a magma_queue_sync on the queue passed to it prior to freeing any memory.

Parameters

  [in,out] | precond_par | magma_s_preconditioner* structure containing all preconditioner information
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smprepare_batched()

magma_int_t magma_smprepare_batched | ( | magma_uplo_t | uplotype,
|  | magma_trans_t | transtype,
|  | magma_diag_t | diagtype,
|  | magma_s_matrix | L,
|  | magma_s_matrix | LC,
|  | magma_index_t * | sizes,
|  | magma_index_t * | locations,
|  | float * | trisystems,
|  | float * | rhs,
|  | magma_queue_t | queue )

Takes a sparse matrix and generates an array containing the sizes of the different systems an array containing the indices with the locations in the sparse matrix where the data comes from and goes back to an array containing all the sparse triangular systems.

- padded with zeros to size 32x32 an array containing the RHS

Parameters

  [in] | uplotype | magma_uplo_t lower or upper triangular
  [in] | transtype | magma_trans_t possibility for transposed matrix
  [in] | diagtype | magma_diag_t unit diagonal or not
  [in] | L | magma_s_matrix Matrix in CSR format
  [in] | LC | magma_s_matrix same matrix, also CSR, but col-major
  [in,out] | sizes | magma_int_t* Number of Elements that are replaced.
  [in,out] | locations | magma_int_t* Array indicating the locations.
  [in,out] | trisystems | float* trisystems
  [in,out] | rhs | float* right-hand sides
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtrisolve_batched()

magma_int_t magma_smtrisolve_batched | ( | magma_uplo_t | uplotype,
|  | magma_trans_t | transtype,
|  | magma_diag_t | diagtype,
|  | magma_s_matrix | L,
|  | magma_s_matrix | LC,
|  | magma_index_t * | sizes,
|  | magma_index_t * | locations,
|  | float * | trisystems,
|  | float * | rhs,
|  | magma_queue_t | queue )

Does all triangular solves.

Parameters

  [in] | uplotype | magma_uplo_t lower or upper triangular
  [in] | transtype | magma_trans_t possibility for transposed matrix
  [in] | diagtype | magma_diag_t unit diagonal or not
  [in] | L | magma_s_matrix Matrix in CSR format
  [in] | LC | magma_s_matrix same matrix, also CSR, but col-major
  [out] | sizes | magma_int_t* Number of Elements that are replaced.
  [out] | locations | magma_int_t* Array indicating the locations.
  [out] | trisystems | float* trisystems
  [out] | rhs | float* right-hand sides
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smbackinsert_batched()

magma_int_t magma_smbackinsert_batched | ( | magma_uplo_t | uplotype,
|  | magma_trans_t | transtype,
|  | magma_diag_t | diagtype,
|  | magma_s_matrix * | M,
|  | magma_index_t * | sizes,
|  | magma_index_t * | locations,
|  | float * | trisystems,
|  | float * | rhs,
|  | magma_queue_t | queue )

Inserts the values into the preconditioner matrix.

Parameters

  [in] | uplotype | magma_uplo_t lower or upper triangular
  [in] | transtype | magma_trans_t possibility for transposed matrix
  [in] | diagtype | magma_diag_t unit diagonal or not
  [in,out] | M | magma_s_matrix* SPAI preconditioner CSR col-major
  [out] | sizes | magma_int_t* Number of Elements that are replaced.
  [out] | locations | magma_int_t* Array indicating the locations.
  [out] | trisystems | float* trisystems
  [out] | rhs | float* right-hand sides
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smiluspai_sizecheck()

magma_int_t magma_smiluspai_sizecheck | ( | magma_s_matrix | A,
|  | magma_index_t | batchsize,
|  | magma_index_t * | maxsize,
|  | magma_queue_t | queue )

Checks for a matrix whether the batched ISAI works for a given thread-block size.

Parameters

  [in] | A | magma_s_matrix system matrix
  [in] | batchsize | magma_int_t Size of the batch (GPU thread block).
  [out] | maxsize | magma_int_t* maximum A(:,i) and A(i,:).
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smisai_blockstruct()

magma_int_t magma_smisai_blockstruct | ( | magma_int_t | n,
|  | magma_int_t | bs,
|  | magma_int_t | offs,
|  | magma_uplo_t | uplotype,
|  | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Generates a block-diagonal sparsity pattern with block-size bs.

Parameters

  [in] | n | magma_int_t Size of the matrix.
  [in] | bs | magma_int_t Size of the diagonal blocks.
  [in] | offs | magma_int_t Size of the first diagonal block.
  [in] | uplotype | magma_uplo_t lower or upper triangular
  [in,out] | A | magma_s_matrix* Generated sparsity pattern matrix.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_cup()

magma_int_t magma_smatrix_cup | ( | magma_s_matrix | A,
|  | magma_s_matrix | B,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

Generates a matrix \(U = A \cup B\).

If both matrices have a nonzero value in the same location, the value of A is used.

Parameters

  [in] | A | magma_s_matrix Input matrix 1.
  [in] | B | magma_s_matrix Input matrix 2.
  [out] | U | magma_s_matrix* Not a real matrix, but the list of all matrix entries included in either A or B. No duplicates.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_cap()

magma_int_t magma_smatrix_cap | ( | magma_s_matrix | A,
|  | magma_s_matrix | B,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

Generates a matrix with entries being in both matrices: \(U = A \cap B\).

The values in U are all ones.

Parameters

  [in] | A | magma_s_matrix Input matrix 1.
  [in] | B | magma_s_matrix Input matrix 2.
  [out] | U | magma_s_matrix* Not a real matrix, but the list of all matrix entries included in both A and B.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_negcap()

magma_int_t magma_smatrix_negcap | ( | magma_s_matrix | A,
|  | magma_s_matrix | B,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

Generates a list of matrix entries being part of A but not of B.

U = A \ B The values of A are preserved.

Parameters

  [in] | A | magma_s_matrix Element part of this.
  [in,out] | B | magma_s_matrix Not part of this.
  [out] | U | magma_s_matrix* Not a real matrix, but the list of all matrix entries included in A not in B.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_tril_negcap()

magma_int_t magma_smatrix_tril_negcap | ( | magma_s_matrix | A,
|  | magma_s_matrix | B,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

Generates a list of matrix entries being part of tril(A) but not of B.

U = tril(A) \ B The values of A are preserved.

Parameters

  [in] | A | magma_s_matrix Element part of this.
  [in,out] | B | magma_s_matrix Not part of this.
  [out] | U | magma_s_matrix* Not a real matrix, but the list of all matrix entries included in A not in B.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_triu_negcap()

magma_int_t magma_smatrix_triu_negcap | ( | magma_s_matrix | A,
|  | magma_s_matrix | B,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

Generates a matrix with entries being part of triu(A) but not of B.

U = triu(A) \ B The values of A are preserved.

Parameters

  [in] | A | magma_s_matrix Element part of this.
  [in] | B | magma_s_matrix Not part of this.
  [out] | U | magma_s_matrix*
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_addrowindex()

magma_int_t magma_smatrix_addrowindex | ( | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Adds to a CSR matrix an array containing the rowindexes.

Parameters

  [in,out] | A | magma_s_matrix* Matrix where rowindexes should be added.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsrcoo_transpose()

magma_int_t magma_scsrcoo_transpose | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Transposes a matrix that already contains rowidx.

The idea is to use a linked list.

Parameters

  [in] | A | magma_s_matrix Matrix to transpose.
  [out] | B | magma_s_matrix* Transposed matrix.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_createrowptr()

magma_int_t magma_smatrix_createrowptr | ( | magma_int_t | n,
|  | magma_index_t * | row,
|  | magma_queue_t | queue )

This function generates a rowpointer out of a row-wise element count in parallel.

Parameters

  [in] | n | magma_indnt_t row-count.
  [in,out] | row | magma_index_t* Input: Vector of size n+1 containing the row-counts (offset by one). Output: Rowpointer.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_swap()

magma_int_t magma_smatrix_swap | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Swaps two matrices.

Useful if a loop modifies the name of a matrix.

Parameters

  [in,out] | A | magma_s_matrix* Matrix to be swapped with B.
  [in,out] | B | magma_s_matrix* Matrix to be swapped with A.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_tril()

magma_int_t magma_smatrix_tril | ( | magma_s_matrix | A,
|  | magma_s_matrix * | L,
|  | magma_queue_t | queue )

Extracts the lower triangular of a matrix: L = tril(A).

The values of A are preserved.

Parameters

  [in] | A | magma_s_matrix Element part of this.
  [out] | L | magma_s_matrix* Lower triangular part of A.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_triu()

magma_int_t magma_smatrix_triu | ( | magma_s_matrix | A,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

Extracts the lower triangular of a matrix: U = triu(A).

The values of A are preserved.

Parameters

  [in] | A | magma_s_matrix Element part of this.
  [out] | U | magma_s_matrix* Lower triangular part of A.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_abssum()

magma_int_t magma_smatrix_abssum | ( | magma_s_matrix | A,
|  | float * | sum,
|  | magma_queue_t | queue )

Computes the sum of the absolute values in a matrix.

Parameters

  [in] | A | magma_s_matrix Element list/matrix.
  [out] | sum | float* Sum of the absolute values.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsr_sort()

magma_int_t magma_scsr_sort | ( | magma_s_matrix * | A,
|  | magma_queue_t | queue )

SOrts the elements in a CSR matrix for increasing column index.

Parameters

  [in,out] | A | magma_s_matrix* CSR matrix, sorted on output.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_srowentries()

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] | A | magma_s_matrix* sparse matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sdiameter()

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] | A | magma_s_matrix* sparse matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_csr_compressor()

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] | val | float** input val pointer to compress
  [in] | row | magma_int_t** input row pointer to modify
  [in] | col | magma_int_t** input col pointer to compress
  [in] | valn | float** output val pointer
  [out] | rown | magma_int_t** output row pointer
  [out] | coln | magma_int_t** output col pointer
  [out] | n | magma_int_t* number of rows in matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smconvert()

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] | A | magma_s_matrix sparse matrix A
  [out] | B | magma_s_matrix* copy of A in new format
  [in] | old_format | magma_storage_t original storage format
  [in] | new_format | magma_storage_t new storage format
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smcsrcompressor()

magma_int_t magma_smcsrcompressor | ( | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Removes zeros in a CSR matrix.

Parameters

  [in,out] | A | magma_s_matrix* input/output matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsrset()

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] | m | magma_int_t number of rows
  [in] | n | magma_int_t number of columns
  [in] | row | magma_index_t* row pointer
  [in] | col | magma_index_t* column indices
  [in] | val | float* array containing matrix entries
  [out] | A | magma_s_matrix* matrix in magma sparse matrix format
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsrget()

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] | A | magma_s_matrix magma sparse matrix in CSR format
  [out] | m | magma_int_t number of rows
  [out] | n | magma_int_t number of columns
  [out] | row | magma_index_t* row pointer
  [out] | col | magma_index_t* column indices
  [out] | val | float* array containing matrix entries
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsrset_gpu()

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] | m | magma_int_t number of rows
  [in] | n | magma_int_t number of columns
  [in] | row | magmaIndex_ptr row pointer
  [in] | col | magmaIndex_ptr column indices
  [in] | val | magmaFloat_ptr array containing matrix entries
  [out] | A | magma_s_matrix* matrix in magma sparse matrix format
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsrget_gpu()

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] | A | magma_s_matrix magma sparse matrix in CSR format
  [out] | m | magma_int_t number of rows
  [out] | n | magma_int_t number of columns
  [out] | row | magmaIndex_ptr row pointer
  [out] | col | magmaIndex_ptr column indices
  [out] | val | magmaFloat_ptr array containing matrix entries
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smdiagdom()

magma_int_t magma_smdiagdom | ( | magma_s_matrix | M,
|  | float * | min_dd,
|  | float * | max_dd,
|  | float * | avg_dd,
|  | magma_queue_t | queue )

This routine takes a CSR matrix and computes the average diagonal dominance.

For each row i, it computes the abs(d_ii)/sum_j(abs(a_ij)). It returns max, min, and average.

Parameters

  [in] | M | magma_s_matrix System matrix.
  [out] | min_dd | float Smallest diagonal dominance.
  [out] | max_dd | float Largest diagonal dominance.
  [out] | avg_dd | float Average diagonal dominance.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smbdiagdom()

magma_int_t magma_smbdiagdom | ( | magma_s_matrix | M,
|  | magma_s_matrix | blocksizes,
|  | float * | min_dd,
|  | float * | max_dd,
|  | float * | avg_dd,
|  | magma_queue_t | queue )

This routine takes a CSR matrix and computes the average block-diagonal dominance.

For each row i, it computes the abs( D_(i,:) ) / abs( A(i,:) \ D_(i,:) ). It returns max, min, and average. The input vector bsz contains the blocksizes.

Parameters

  [in] | M | magma_s_matrix System matrix.
  [in] | blocksizes | magma_s_matrix Vector containing blocksizes (as DoubleComplex).
  [out] | min_dd | float Smallest diagonal dominance.
  [out] | max_dd | float Largest diagonal dominance.
  [out] | avg_dd | float Average diagonal dominance.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smdiff()

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] | A | magma_s_matrix sparse matrix in CSR
  [in] | B | magma_s_matrix sparse matrix in CSR
  [out] | res | real_Double_t* residual
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smfrobenius()

magma_int_t magma_smfrobenius | ( | magma_s_matrix | A,
|  | magma_s_matrix | B,
|  | magma_s_matrix | S,
|  | float * | norm,
|  | magma_queue_t | queue )

Computes the Frobenius norm || A - B ||_S on the sparsity pattern of S.

Parameters

  [in] | A | magma_s_matrix input sparse matrix in CSR
  [in] | B | magma_s_matrix input sparse matrix in CSR
  [in] | S | magma_s_matrix input sparsity pattern in CSR
  [out] | norm | float* Frobenius norm of difference on sparsity pattern S
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smgenerator()

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] | n | magma_int_t number of rows
  [in] | offdiags | magma_int_t number of offdiagonals

  [in]

  diag_offset

  magma_int_t* array containing the offsets

                                  (length offsets+1)

  [in]

  diag_vals

  float* array containing the values

                                  (length offsets+1)

  [out] | A | magma_s_matrix* matrix to generate
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sm_27stencil()

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] | n | magma_int_t number of rows
  [out] | A | magma_s_matrix* matrix to generate
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sm_5stencil()

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] | n | magma_int_t number of rows
  [out] | A | magma_s_matrix* matrix to generate
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssymbilu()

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] | A | magma_s_matrix* matrix in magma sparse matrix format containing the original matrix on input, and L,U on output
  [in] | levels | magma_magma_int_t_t fill in level
  [out] | L | magma_s_matrix* output lower triangular matrix in magma sparse matrix format empty on function call
  [out] | U | magma_s_matrix* output upper triangular matrix in magma sparse matrix format empty on function call
  [in] | queue | magma_queue_t Queue to execute in.

## read_s_csr_from_mtx()

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] | type | magma_storage_t* storage type of matrix
  [out] | location | magma_location_t* location of matrix
  [out] | n_row | magma_int_t* number of rows in matrix
  [out] | n_col | magma_int_t* number of columns in matrix
  [out] | nnz | magma_int_t* number of nonzeros in matrix
  [out] | val | float** value array of CSR output
  [out] | row | magma_index_t** row pointer of CSR output
  [out] | col | magma_index_t** column indices of CSR output
  [in] | filename | const char* filname of the mtx matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_swrite_csr_mtx()

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] | A | magma_s_matrix matrix to write out
  [in] | MajorType | magma_index_t Row or Column sort default: 0 = RowMajor, 1 = ColMajor TODO: use named constants (e.g., MagmaRowMajor), not numbers.
  [in] | filename | const char* output-filname of the mtx matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sprint_csr_mtx()

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_row | magma_int_t* number of rows in matrix
  [in] | n_col | magma_int_t* number of columns in matrix
  [in] | nnz | magma_int_t* number of nonzeros in matrix
  [in] | val | float** value array of CSR
  [in] | row | magma_index_t** row pointer of CSR
  [in] | col | magma_index_t** column indices of CSR
  [in] | MajorType | magma_index_t Row or Column sort default: 0 = RowMajor, 1 = ColMajor
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sprint_csr()

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_row | magma_int_t* number of rows in matrix
  [in] | n_col | magma_int_t* number of columns in matrix
  [in] | nnz | magma_int_t* number of nonzeros in matrix
  [in] | val | float** value array of CSR
  [in] | row | magma_index_t** row pointer of CSR
  [in] | col | magma_index_t** column indices of CSR
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sprint_matrix()

magma_int_t magma_sprint_matrix | ( | magma_s_matrix | A,
|  | magma_queue_t | queue )

Prints a sparse matrix in CSR format.

Parameters

  [in] | A | magma_s_matrix sparse matrix in Magma_CSR format
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_csr_mtx()

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] | A | magma_s_matrix* matrix in magma sparse matrix format
  [in] | filename | const char* filname of the mtx matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_csr_mtxsymm()

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] | A | magma_s_matrix* matrix in magma sparse matrix format
  [in] | filename | const char* filname of the mtx matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smlumerge()

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] | L | magma_s_matrix input strictly lower triangular matrix L
  [in] | U | magma_s_matrix input upper triangular matrix U
  [out] | A | magma_s_matrix* output matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smscale()

magma_int_t magma_smscale | ( | magma_s_matrix * | A,
|  | magma_scale_t | scaling,
|  | magma_queue_t | queue )

Scales a matrix.

Parameters

  [in,out] | A | magma_s_matrix* input/output matrix
  [in] | scaling | magma_scale_t scaling type (unit rownorm / unit diagonal)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smscale_matrix_rhs()

magma_int_t magma_smscale_matrix_rhs | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | b,
|  | magma_s_matrix * | scaling_factors,
|  | magma_scale_t | scaling,
|  | magma_queue_t | queue )

Scales a matrix and a right hand side vector of a Ax = b system.

Parameters

  [in,out] | A | magma_s_matrix* input/output matrix
  [in,out] | b | magma_s_matrix* input/output right hand side vector
  [out] | scaling_factors | magma_s_matrix* output scaling factors vector
  [in] | scaling | magma_scale_t scaling type (unit rownorm / unit diagonal)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smdiagadd()

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] | A | magma_s_matrix* input/output matrix
  [in] | add | float scaling for the identity matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smscale_generate()

magma_int_t magma_smscale_generate | ( | magma_int_t | n,
|  | magma_scale_t * | scaling,
|  | magma_side_t * | side,
|  | magma_s_matrix * | A,
|  | magma_s_matrix * | scaling_factors,
|  | magma_queue_t | queue )

Generates n vectors of scaling factors from the A matrix and stores them in the factors matrix as column vectors in column major ordering.

Parameters

  [in] | n | magma_int_t number of diagonal scaling matrices
  [in] | scaling | magma_scale_t* array of scaling specifiers
  [in] | side | magma_side_t* array of side specifiers
  [in] | A | magma_s_matrix* input matrix
  [out] | scaling_factors | magma_s_matrix* array of diagonal matrices
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smscale_apply()

magma_int_t magma_smscale_apply | ( | magma_int_t | n,
|  | magma_side_t * | side,
|  | magma_s_matrix * | scaling_factors,
|  | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Applies n diagonal scaling matrices to a matrix A; n=[1,2], factor[i] is applied to side[i] of the matrix.

Parameters

  [in] | n | magma_int_t number of diagonal scaling matrices
  [in] | side | magma_side_t* array of side specifiers
  [in] | scaling_factors | magma_s_matrix* array of diagonal matrices
  [in,out] | A | magma_s_matrix* input/output matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sdimv()

magma_int_t magma_sdimv | ( | magma_s_matrix * | vecA,
|  | magma_s_matrix * | vecB,
|  | magma_queue_t | queue )

Multiplies a diagonal matrix (vecA) and a vector (vecB).

Parameters

  [in] | vecA | magma_s_matrix* input matrix
  [in,out] | vecB | magma_s_matrix* input/output matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smshrink()

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] | A | magma_s_matrix sparse matrix A
  [out] | B | magma_s_matrix* sparse matrix A
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smslice()

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_slices | magma_int_t number of slices
  [in] | slice | magma_int_t slice id (0.. num_slices-1)
  [in] | A | magma_s_matrix sparse matrix in CSR
  [out] | B | magma_s_matrix* sparse matrix in CSR
  [out] | ALOC | magma_s_matrix* sparse matrix in CSR
  [out] | ANLOC | magma_s_matrix* sparse matrix in CSR
  [in,out] | comm_i | magma_int_t* communication plan
  [in,out] | comm_v | float* communication plan
  [in] | queue | magma_queue_t Queue to execute in.
  [out] | start | magma_int_t* start of slice (row-index)
  [out] | end | magma_int_t* end of slice (row-index)

## magma_smsupernodal()

magma_int_t magma_smsupernodal | ( | magma_int_t * | max_bs,
|  | magma_s_matrix | A,
|  | magma_s_matrix * | S,
|  | magma_queue_t | queue )

Generates a block-diagonal sparsity pattern with block-size bs.

Parameters

  [in,out] | max_bs | magma_int_t* Size of the largest diagonal block.
  [in] | A | magma_s_matrix System matrix.
  [in,out] | S | magma_s_matrix* Generated sparsity pattern matrix.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smvarsizeblockstruct()

magma_int_t magma_smvarsizeblockstruct | ( | magma_int_t | n,
|  | magma_int_t * | bs,
|  | magma_int_t | bsl,
|  | magma_uplo_t | uplotype,
|  | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Generates a block-diagonal sparsity pattern with variable block-size.

Parameters

  [in] | n | magma_int_t Size of the matrix.
  [in] | bs | magma_int_t* Vector containing the size of the diagonal blocks.
  [in] | bsl | magma_int_t Size of the vector containing the block sizes.
  [in] | uplotype | magma_uplo_t lower or upper triangular
  [in,out] | A | magma_s_matrix* Generated sparsity pattern matrix.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtransfer()

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] | A | magma_s_matrix sparse matrix A
  [out] | B | magma_s_matrix* copy of A
  [in] | src | magma_location_t original location A
  [in] | dst | magma_location_t location of the copy of A
  [in] | queue | magma_queue_t Queue to execute in.

## s_transpose_csr()

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_rows | magma_int_t number of rows in input matrix
  [in] | n_cols | magma_int_t number of columns in input matrix
  [in] | nnz | magma_int_t number of nonzeros in input matrix
  [in] | values | float* value array of input matrix
  [in] | rowptr | magma_index_t* row pointer of input matrix
  [in] | colind | magma_index_t* column indices of input matrix
  [in] | new_n_rows | magma_index_t* number of rows in transposed matrix
  [in] | new_n_cols | magma_index_t* number of columns in transposed matrix
  [in] | new_nnz | magma_index_t* number of nonzeros in transposed matrix
  [in] | new_values | float** value array of transposed matrix
  [in] | new_rowptr | magma_index_t** row pointer of transposed matrix
  [in] | new_colind | magma_index_t** column indices of transposed matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtranspose()

magma_int_t magma_smtranspose | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Interface to cuSPARSE transpose.

Parameters

  [in] | A | magma_s_matrix input matrix (CSR)
  [out] | B | magma_s_matrix* output matrix (CSR)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_s_cucsrtranspose()

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] | A | magma_s_matrix input matrix (CSR)
  [out] | B | magma_s_matrix* output matrix (CSR)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtransposeconjugate()

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] | A | magma_s_matrix input matrix (CSR)
  [out] | B | magma_s_matrix* output matrix (CSR)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtranspose_cpu()

magma_int_t magma_smtranspose_cpu | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Generates a transpose of A on the CPU.

Parameters

  [in] | A | magma_s_matrix input matrix (CSR)
  [out] | B | magma_s_matrix* output matrix (CSR)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtransposeconj_cpu()

magma_int_t magma_smtransposeconj_cpu | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Generates a transpose conjugate of A on the CPU.

Parameters

  [in] | A | magma_s_matrix input matrix (CSR)
  [out] | B | magma_s_matrix* output matrix (CSR)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtransposestruct_cpu()

magma_int_t magma_smtransposestruct_cpu | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Generates a transpose of the nonzero pattern of A on the CPU.

Parameters

  [in] | A | magma_s_matrix input matrix (CSR)
  [out] | B | magma_s_matrix* output matrix (CSR)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtransposeabs_cpu()

magma_int_t magma_smtransposeabs_cpu | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Generates a transpose with absolute values of A on the CPU.

Parameters

  [in] | A | magma_s_matrix input matrix (CSR)
  [out] | B | magma_s_matrix* output matrix (CSR)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparic_sweep()

magma_int_t magma_sparic_sweep | ( | magma_s_matrix | A,
|  | magma_s_matrix * | L,
|  | magma_queue_t | queue )

This function does one asynchronous ParILU sweep (symmetric case).

Input and output array is identical.

Parameters

  [in] | A | magma_s_matrix System matrix in COO.
  [in] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is sorted CSR.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparic_sweep_sync()

magma_int_t magma_sparic_sweep_sync | ( | magma_s_matrix | A,
|  | magma_s_matrix * | L,
|  | magma_queue_t | queue )

This function does one synchronized ParILU sweep (symmetric case).

Input and output are different arrays.

Parameters

  [in] | A | magma_s_matrix System matrix in COO.
  [in] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is sorted CSR.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparict_candidates()

magma_int_t magma_sparict_candidates | ( | magma_s_matrix | L0,
|  | magma_s_matrix | L,
|  | magma_s_matrix | LT,
|  | magma_s_matrix * | L_new,
|  | magma_queue_t | queue )

This function identifies the candidates like they appear as ILU1 fill-in.

In this version, the matrices are assumed unordered, the linked list is traversed to acces the entries of a row.

Parameters

  [in] | L0 | magma_s_matrix tril( ILU(0) ) pattern of original system matrix.
  [in] | L | magma_s_matrix Current lower triangular factor.
  [in] | LT | magma_s_matrix Transose of the lower triangular factor.
  [in,out] | L_new | magma_s_matrix* List of candidates for L in COO format.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparict_sweep_sync()

magma_int_t magma_sparict_sweep_sync | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | L,
|  | magma_queue_t | queue )

This function does one synchronized ParILU sweep.

Input and output are different arrays.

Parameters

  [in] | A | magma_s_matrix* System matrix.
  [in] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is sorted CSR.
  [in] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is sorted CSC.
  [out] | L_new | magma_s_matrix* Current approximation for the lower triangular factor The format is unsorted CSR.
  [out] | U_new | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSC.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilu_sweep()

magma_int_t magma_sparilu_sweep | ( | magma_s_matrix | A,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

This function does one asynchronous ParILU sweep.

Input and output array are identical.

Parameters

  [in] | A | magma_s_matrix System matrix in COO.
  [in] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is sorted CSR.
  [in] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is sorted CSC (U^T in CSR).
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilu_sweep_sync()

magma_int_t magma_sparilu_sweep_sync | ( | magma_s_matrix | A,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

This function does one synchronized ParILU sweep.

Input and output are different arrays.

Parameters

  [in] | A | magma_s_matrix System matrix in COO.
  [in] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is sorted CSR.
  [in] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is sorted CSC (U^T in CSR).
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_sweep()

magma_int_t magma_sparilut_sweep | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

This function does an ParILUT sweep.

The difference to the ParILU sweep is that the nonzero pattern of A and the incomplete factors L and U can be different. The pattern determing which elements are iterated are hence the pattern of L and U, not A.

This is the CPU version of the asynchronous ParILUT sweep.

Parameters

  [in] | A | magma_s_matrix* System matrix. The format is sorted CSR.
  [in,out] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is MAGMA_CSRCOO. This is sorted CSR plus the rowindexes being stored.
  [in,out] | U | magma_s_matrix* Current approximation for the lower triangular factor The format is MAGMA_CSRCOO. This is sorted CSR plus the rowindexes being stored.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_sweep_sync()

magma_int_t magma_sparilut_sweep_sync | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

This function does an ParILUT sweep.

The difference to the ParILU sweep is that the nonzero pattern of A and the incomplete factors L and U can be different. The pattern determing which elements are iterated are hence the pattern of L and U, not A.

This is the CPU version of the synchronous ParILUT sweep.

Parameters

  [in] | A | magma_s_matrix* System matrix. The format is sorted CSR.
  [in,out] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is MAGMA_CSRCOO. This is sorted CSR plus the rowindexes being stored.
  [in,out] | U | magma_s_matrix* Current approximation for the lower triangular factor The format is MAGMA_CSRCOO. This is sorted CSR plus the rowindexes being stored.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_residuals()

magma_int_t magma_sparilut_residuals | ( | magma_s_matrix | A,
|  | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | R,
|  | magma_queue_t | queue )

This function computes the ILU residual in the locations included in the sparsity pattern of R.

Parameters

  [in] | A | magma_s_matrix System matrix A.
  [in] | L | magma_s_matrix Current approximation for the lower triangular factor. The format is sorted CSR.
  [in] | U | magma_s_matrix Current approximation for the upper triangular factor. The format is sorted CSR.
  [in,out] | R | magma_s_matrix* Sparsity pattern on which the ILU residual is computed. R is in COO format. On output, R contains the ILU residual.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_thrsrm()

magma_int_t magma_sparilut_thrsrm | ( | magma_int_t | order,
|  | magma_s_matrix * | A,
|  | float * | thrs,
|  | magma_queue_t | queue )

Removes any element with absolute value smaller equal or larger equal thrs from the matrix and compacts the whole thing.

Parameters

  [in] | order | magma_int_t order == 1: all elements smaller are discarded order == 0: all elements larger are discarded
  [in,out] | A | magma_s_matrix* Matrix where elements are removed.
  [in] | thrs | float* Threshold: all elements smaller are discarded
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_thrsrm_U()

magma_int_t magma_sparilut_thrsrm_U | ( | magma_int_t | order,
|  | magma_s_matrix | L,
|  | magma_s_matrix * | A,
|  | float * | thrs,
|  | magma_queue_t | queue )

Removes any element with absolute value smaller equal or larger equal thrs from the matrix and compacts the whole thing.

Parameters

  [in] | order | magma_int_t order == 1: all elements smaller are discarded order == 0: all elements larger are discarded
  [in,out] | A | magma_s_matrix* Matrix where elements are removed.
  [in] | thrs | float* Threshold: all elements smaller are discarded
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_rmselected()

magma_int_t magma_sparilut_rmselected | ( | magma_s_matrix | R,
|  | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Removes a selected list of elements from the matrix.

Parameters

  [in] | R | magma_s_matrix Matrix containing elements to be removed.
  [in,out] | A | magma_s_matrix* Matrix where elements are removed.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_selectoneperrow()

magma_int_t magma_sparilut_selectoneperrow | ( | magma_int_t | order,
|  | magma_s_matrix * | A,
|  | magma_s_matrix * | oneA,
|  | magma_queue_t | queue )

This function takes a list of candidates with residuals, and selects the largest in every row.

The output matrix only contains these largest elements (respectively a zero element if there is no candidate for a certain row).

Parameters

  [in] | order | magma_int_t order==1 -> largest order==0 -> smallest
  [in] | A | magma_s_matrix* Matrix where elements are removed.
  [out] | oneA | magma_s_matrix* Matrix where elements are removed.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_selecttwoperrow()

magma_int_t magma_sparilut_selecttwoperrow | ( | magma_int_t | order,
|  | magma_s_matrix * | A,
|  | magma_s_matrix * | oneA,
|  | magma_queue_t | queue )

This function takes a list of candidates with residuals, and selects the largest in every row.

The output matrix only contains these largest elements (respectively a zero element if there is no candidate for a certain row).

Parameters

  [in] | order | magma_int_t order==1 -> largest order==0 -> smallest
  [in] | A | magma_s_matrix* Matrix where elements are removed.
  [out] | oneA | magma_s_matrix* Matrix where elements are removed.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_selectoneperrowthrs_lower()

magma_int_t magma_sparilut_selectoneperrowthrs_lower | ( | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | A,
|  | float | rtol,
|  | magma_s_matrix * | oneA,
|  | magma_queue_t | queue )

This function takes a list of candidates with residuals, and selects the largest in every row.

The output matrix only contains these largest elements (respectively a zero element if there is no candidate for a certain row).

Parameters

  [in] | L | magma_s_matrix Current lower triangular factor.
  [in] | U | magma_s_matrix Current upper triangular factor.
  [in] | A | magma_s_matrix* All residuals in L.
  [in] | rtol | threshold rtol
  [out] | oneA | magma_s_matrix* at most one per row, if larger thrs.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_selectoneperrowthrs_upper()

magma_int_t magma_sparilut_selectoneperrowthrs_upper | ( | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | A,
|  | float | rtol,
|  | magma_s_matrix * | oneA,
|  | magma_queue_t | queue )

This function takes a list of candidates with residuals, and selects the largest in every row.

The output matrix only contains these largest elements (respectively a zero element if there is no candidate for a certain row).

Parameters

  [in] | L | magma_s_matrix Current lower triangular factor.
  [in] | U | magma_s_matrix Current upper triangular factor.
  [in] | A | magma_s_matrix* All residuals in L.
  [in] | rtol | threshold rtol
  [out] | oneA | magma_s_matrix* at most one per row, if larger thrs.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_preselect()

magma_int_t magma_sparilut_preselect | ( | magma_int_t | order,
|  | magma_s_matrix * | A,
|  | magma_s_matrix * | oneA,
|  | magma_queue_t | queue )

This function takes a list of candidates with residuals, and selects the largest in every row.

The output matrix only contains these largest elements (respectively a zero element if there is no candidate for a certain row).

Parameters

  [in] | order | magma_int_t order==0 lower triangular order==1 upper triangular
  [in] | A | magma_s_matrix* Matrix where elements are removed.
  [out] | oneA | magma_s_matrix* Matrix where elements are removed.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_preselect_scale()

magma_int_t magma_sparilut_preselect_scale | ( | magma_s_matrix * | L,
|  | magma_s_matrix * | oneL,
|  | magma_s_matrix * | U,
|  | magma_s_matrix * | oneU,
|  | magma_queue_t | queue )

This function takes a list of candidates with residuals, and selects the largest in every row.

The output matrix only contains these largest elements (respectively a zero element if there is no candidate for a certain row).

Parameters

  [in] | L | magma_s_matrix* Matrix where elements are removed.
  [in] | U | magma_s_matrix* Matrix where elements are removed.
  [out] | oneL | magma_s_matrix* Matrix where elements are removed.
  [out] | oneU | magma_s_matrix* Matrix where elements are removed.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_transpose()

magma_int_t magma_sparilut_transpose | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

Transposes a matrix that already contains rowidx.

The idea is to use a linked list.

Parameters

  [in] | A | magma_s_matrix Matrix to transpose.
  [out] | B | magma_s_matrix* Transposed matrix.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_transpose_select_one()

magma_int_t magma_sparilut_transpose_select_one | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

This is a special routine with very limited scope.

For a set of fill-in candidates in row-major format, it transposes the a submatrix, i.e. the submatrix consisting of the largest element in every column. This function is only useful for delta<=1.

Parameters

  [in] | A | magma_s_matrix Matrix to transpose.
  [out] | B | magma_s_matrix* Transposed matrix containing only largest elements in each col.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_create_collinkedlist()

magma_int_t magma_sparilut_create_collinkedlist | ( | magma_s_matrix | A,
|  | magma_s_matrix * | B,
|  | magma_queue_t | queue )

For the matrix U in CSR (row-major) this creates B containing a row-ptr to the columns and a linked list for the elements.

Parameters

  [in] | A | magma_s_matrix Matrix to transpose.
  [out] | B | magma_s_matrix* Transposed matrix.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_sweep_semilinked()

magma_int_t magma_sparilut_sweep_semilinked | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | US,
|  | magma_queue_t | queue )

This function does an ParILU sweep.

Parameters

  [in,out] | A | magma_s_matrix* Current ILU approximation The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_sweep_list()

magma_int_t magma_sparilut_sweep_list | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

This function does an ParILU sweep.

Parameters

  [in,out] | A | magma_s_matrix* Current ILU approximation The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_residuals_semilinked()

magma_int_t magma_sparilut_residuals_semilinked | ( | magma_s_matrix | A,
|  | magma_s_matrix | L,
|  | magma_s_matrix | US,
|  | magma_s_matrix * | L_new,
|  | magma_queue_t | queue )

This function computes the residuals.

Parameters

  [in,out] | L | magma_s_matrix Current approximation for the lower triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_residuals_transpose()

magma_int_t magma_sparilut_residuals_transpose | ( | magma_s_matrix | A,
|  | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | U_new,
|  | magma_queue_t | queue )

This function computes the residuals.

Parameters

  [in,out] | L | magma_s_matrix Current approximation for the lower triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_residuals_list()

magma_int_t magma_sparilut_residuals_list | ( | magma_s_matrix | A,
|  | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | L_new,
|  | magma_queue_t | queue )

This function computes the residuals.

Parameters

  [in,out] | L | magma_s_matrix Current approximation for the lower triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_sweep_linkedlist()

magma_int_t magma_sparilut_sweep_linkedlist | ( | magma_s_matrix * | A,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

This function does an ParILU sweep.

Parameters

  [in,out] | A | magma_s_matrix* Current ILU approximation The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | L | magma_s_matrix* Current approximation for the lower triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_residuals_linkedlist()

magma_int_t magma_sparilut_residuals_linkedlist | ( | magma_s_matrix | A,
|  | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | L_new,
|  | magma_queue_t | queue )

This function computes the residuals.

Parameters

  [in,out] | L | magma_s_matrix Current approximation for the lower triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* Current approximation for the upper triangular factor The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_colmajor()

magma_int_t magma_sparilut_colmajor | ( | magma_s_matrix | A,
|  | magma_s_matrix * | AC,
|  | magma_queue_t | queue )

This function creates a col-pointer and a linked list along the columns for a row-major CSR matrix.

Parameters

  [in] | A | magma_s_matrix The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | AC | magma_s_matrix* The matrix A but with row-pointer being for col-major, same with linked list. The values, col and row indices are unchanged. The respective pointers point to the entities of A.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_reorder()

magma_int_t magma_sparilut_reorder | ( | magma_s_matrix * | LU,
|  | magma_queue_t | queue )

This routine reorders the matrix (inplace) for easier access.

Parameters

  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_colmajorup()

magma_int_t magma_sparilut_colmajorup | ( | magma_s_matrix | A,
|  | magma_s_matrix * | AC,
|  | magma_queue_t | queue )

This function creates a col-pointer and a linked list along the columns for a row-major CSR matrix.

Parameters

  [in] | A | magma_s_matrix The format is unsorted CSR, the list array is used as linked list pointing to the respectively next entry.
  [in,out] | AC | magma_s_matrix* The matrix A but with row-pointer being for col-major, same with linked list. The values, col and row indices are unchanged. The respective pointers point to the entities of A. Already allocated.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_insert()

magma_int_t magma_sparilut_insert | ( | magma_int_t * | num_rmL,
|  | magma_int_t * | num_rmU,
|  | magma_index_t * | rm_locL,
|  | magma_index_t * | rm_locU,
|  | magma_s_matrix * | L_new,
|  | magma_s_matrix * | U_new,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_s_matrix * | UR,
|  | magma_queue_t | queue )

Inserts for the iterative dynamic ILU an new element in the (empty) place.

Parameters

  [in] | num_rmL | magma_int_t Number of Elements that are replaced in L.
  [in] | num_rmU | magma_int_t Number of Elements that are replaced in U.
  [in] | rm_locL | magma_index_t* List containing the locations of the deleted elements.
  [in] | rm_locU | magma_index_t* List containing the locations of the deleted elements.
  [in] | L_new | magma_s_matrix Elements that will be inserted in L stored in COO format (unsorted).
  [in] | U_new | magma_s_matrix Elements that will be inserted in U stored in COO format (unsorted).
  [in,out] | L | magma_s_matrix* matrix where new elements are inserted. The format is unsorted CSR, list is used as linked list pointing to the respectively next entry.
  [in,out] | U | magma_s_matrix* matrix where new elements are inserted. Row-major. The format is unsorted CSR, list is used as linked list pointing to the respectively next entry.
  [in,out] | UR | magma_s_matrix* Same matrix as U, but column-major. The format is unsorted CSR, list is used as linked list pointing to the respectively next entry.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_candidates()

magma_int_t magma_sparilut_candidates | ( | magma_s_matrix | L0,
|  | magma_s_matrix | U0,
|  | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | L_new,
|  | magma_s_matrix * | U_new,
|  | magma_queue_t | queue )

This function identifies the candidates like they appear as ILU1 fill-in.

In this version, the matrices are assumed unordered, the linked list is traversed to acces the entries of a row.

Parameters

  [in] | L0 | magma_s_matrix tril( ILU(0) ) pattern of original system matrix.
  [in] | U0 | magma_s_matrix triu( ILU(0) ) pattern of original system matrix.
  [in] | L | magma_s_matrix Current lower triangular factor.
  [in] | U | magma_s_matrix Current upper triangular factor.
  [in,out] | LU_new | magma_s_matrix* List of candidates for L in COO format.
  [in,out] | LU_new | magma_s_matrix* List of candidates for U in COO format.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_candidates_semilinked()

magma_int_t magma_sparilut_candidates_semilinked | ( | magma_s_matrix | L0,
|  | magma_s_matrix | U0,
|  | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix | UT,
|  | magma_s_matrix * | L_new,
|  | magma_s_matrix * | U_new,
|  | magma_queue_t | queue )

This function identifies the candidates like they appear as ILU1 fill-in.

In this version, the matrices are assumed unordered, the linked list is traversed to acces the entries of a row.

Parameters

  [in] | L0 | magma_s_matrix tril( ILU(0) ) pattern of original system matrix.
  [in] | U0 | magma_s_matrix triu( ILU(0) ) pattern of original system matrix.
  [in] | L | magma_s_matrix Current lower triangular factor.
  [in] | U | magma_s_matrix Current upper triangular factor transposed.
  [in] | UR | magma_s_matrix Current upper triangular factor - col-pointer and col-list.
  [in,out] | LU_new | magma_s_matrix* List of candidates for L in COO format.
  [in,out] | LU_new | magma_s_matrix* List of candidates for U in COO format.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_rm_thrs()

magma_int_t magma_sparilut_rm_thrs | ( | float * | thrs,
|  | magma_int_t * | num_rm,
|  | magma_s_matrix * | LU,
|  | magma_s_matrix * | LU_new,
|  | magma_index_t * | rm_loc,
|  | magma_queue_t | queue )

This routine removes matrix entries from the structure that are smaller than the threshold.

It only counts the elements deleted, does not save the locations.

Parameters

  [out] | thrs | float* Thrshold for removing elements.
  [out] | num_rm | magma_int_t* Number of Elements that have been removed.
  [in,out] | LU | magma_s_matrix* Current ILU approximation where the identified smallest components are deleted.
  [in,out] | LUC | magma_s_matrix* Corresponding col-list.
  [in,out] | LU_new | magma_s_matrix* List of candidates in COO format.
  [out] | rm_loc | magma_index_t* List containing the locations of the elements deleted.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_count()

magma_int_t magma_sparilut_count | ( | magma_s_matrix | L,
|  | magma_int_t * | num,
|  | magma_queue_t | queue )

This is a helper routine counting elements in a matrix in unordered Magma_CSRLIST format.

Parameters

  [in] | L | magma_s_matrix* Matrix in Magm_CSRLIST format
  [out] | num | magma_index_t* Number of elements counted.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_select_candidates_L()

magma_int_t magma_sparilut_select_candidates_L | ( | magma_int_t * | num_rm,
|  | magma_index_t * | rm_loc,
|  | magma_s_matrix * | L_new,
|  | magma_queue_t | queue )

Screens the new candidates for multiple elements in the same row.

We allow for at most one new element per row. This changes the algorithm, but pays off in performance.

Parameters

  [in] | num_rmL | magma_int_t Number of Elements that are replaced.
  [in] | num_rmU | magma_int_t Number of Elements that are replaced.
  [in] | rm_loc | magma_int_t* Number of Elements that are replaced by distinct threads.
  [in] | L_new | magma_s_matrix* Elements that will be inserted stored in COO format (unsorted).
  [in] | U_new | magma_s_matrix* Elements that will be inserted stored in COO format (unsorted).
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_select_candidates_U()

magma_int_t magma_sparilut_select_candidates_U | ( | magma_int_t * | num_rm,
|  | magma_index_t * | rm_loc,
|  | magma_s_matrix * | L_new,
|  | magma_queue_t | queue )

Screens the new candidates for multiple elements in the same row.

We allow for at most one new element per row. This changes the algorithm, but pays off in performance.

Parameters

  [in] | num_rmL | magma_int_t Number of Elements that are replaced.
  [in] | num_rmU | magma_int_t Number of Elements that are replaced.
  [in] | rm_loc | magma_int_t* Number of Elements that are replaced by distinct threads.
  [in] | L_new | magma_s_matrix* Elements that will be inserted stored in COO format (unsorted).
  [in] | U_new | magma_s_matrix* Elements that will be inserted stored in COO format (unsorted).
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_approx_thrs()

magma_int_t magma_sparilut_set_approx_thrs | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | LU,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine approximates the threshold for removing num_rm elements.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_thrs_randomselect()

magma_int_t magma_sparilut_set_thrs_randomselect | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | LU,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine approximates the threshold for removing num_rm elements.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_thrs_L_scaled()

magma_int_t magma_sparilut_set_thrs_L_scaled | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine approximates the threshold for removing num_rm elements.

It takes into account the scaling with the diagonal.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | L | magma_s_matrix* Current L approximation.
  [in] | U | magma_s_matrix* Current U approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_thrs_randomselect_approx2()

magma_int_t magma_sparilut_set_thrs_randomselect_approx2 | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | LU,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine approximates the threshold for removing num_rm elements.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_thrs_randomselect_approx()

magma_int_t magma_sparilut_set_thrs_randomselect_approx | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | LU,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine approximates the threshold for removing num_rm elements.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_thrs_randomselect_factors()

magma_int_t magma_sparilut_set_thrs_randomselect_factors | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | L,
|  | magma_s_matrix * | U,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine approximates the threshold for removing num_rm elements.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_exact_thrs()

magma_int_t magma_sparilut_set_exact_thrs | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | LU,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine provides the exact threshold for removing num_rm elements.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_set_approx_thrs_inc()

magma_int_t magma_sparilut_set_approx_thrs_inc | ( | magma_int_t | num_rm,
|  | magma_s_matrix * | LU,
|  | magma_int_t | order,
|  | float * | thrs,
|  | magma_queue_t | queue )

This routine provides the exact threshold for removing num_rm elements.

Parameters

  [in] | num_rm | magma_int_t Number of Elements that are replaced.
  [in] | LU | magma_s_matrix* Current ILU approximation.
  [in] | order | magma_int_t Sort goal function: 0 = smallest, 1 = largest.
  [out] | thrs | float* Size of the num_rm-th smallest element.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_align_residuals()

magma_int_t magma_sparilut_align_residuals | ( | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | Lnew,
|  | magma_s_matrix * | Unew,
|  | magma_queue_t | queue )

This function scales the residuals of a lower triangular factor L with the diagonal of U.

The intention is to generate a good initial guess for inserting the elements.

Parameters

  [in] | L | magma_s_matrix Current approximation for the lower triangular factor The format is sorted CSR.
  [in] | U | magma_s_matrix Current approximation for the upper triangular factor The format is sorted CSC.
  [in] | hL | magma_s_matrix* Current approximation for the lower triangular factor The format is sorted CSR.
  [in] | hU | magma_s_matrix* Current approximation for the upper triangular factor The format is sorted CSC.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sfrobenius()

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] | A | magma_s_matrix sparse matrix in CSR
  [in] | B | magma_s_matrix sparse matrix in CSR
  [out] | res | real_Double_t* Frobenius norm of difference
  [in] | queue | magma_queue_t Queue to execute in.

## magma_snonlinres()

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] | A | magma_s_matrix input sparse matrix in CSR
  [in] | L | magma_s_matrix input sparse matrix in CSR
  [in] | U | magma_s_matrix input sparse matrix in CSR
  [out] | LU | magma_s_matrix* output sparse matrix in A-LU in CSR
  [out] | res | real_Double_t* Frobenius norm of difference
  [in] | queue | magma_queue_t Queue to execute in.

## magma_silures()

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] | A | magma_s_matrix input sparse matrix in CSR
  [in] | L | magma_s_matrix input sparse matrix in CSR
  [in] | U | magma_s_matrix input sparse matrix in CSR
  [out] | LU | magma_s_matrix* output sparse matrix in A-LU in CSR
  [out] | res | real_Double_t* Frobenius norm of difference
  [out] | nonlinres | real_Double_t* Frobenius norm of difference
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sicres()

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] | A | magma_s_matrix input sparse matrix in CSR
  [in] | C | magma_s_matrix input sparse matrix in CSR
  [in] | CT | magma_s_matrix input sparse matrix in CSR
  [in] | LU | magma_s_matrix* output sparse matrix in A-LU in CSR
  [out] | res | real_Double_t* IC residual
  [out] | nonlinres | real_Double_t* nonlinear residual
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sinitguess()

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 ParILU/ParIC.

Parameters

  [in] | A | magma_s_matrix sparse matrix in CSR
  [out] | L | magma_s_matrix* sparse matrix in CSR
  [out] | U | magma_s_matrix* sparse matrix in CSR
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sinitrecursiveLU()

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] | A | magma_s_matrix* sparse matrix in CSR
  [out] | B | magma_s_matrix* sparse matrix in CSR
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smLdiagadd()

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] | L | magma_s_matrix* sparse matrix in CSR
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sselect()

magma_int_t magma_sselect | ( | float * | a,
|  | magma_int_t | size,
|  | magma_int_t | k,
|  | magma_queue_t | queue )

An efficient implementation of Blum, Floyd, Pratt, Rivest, and Tarjan's worst-case linear selection algorithm.

Derrick Coetzee, webma.nosp@m.ster.nosp@m.@moon.nosp@m.flar.nosp@m.e.com January 22, 2004 http://moonflare.com/code/select/select.pdf

Parameters

  [in,out] | a | float* array to select from
  [in] | size | magma_int_t size of array
  [in] | k | magma_int_t k-th smallest element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sselectrandom()

magma_int_t magma_sselectrandom | ( | float * | a,
|  | magma_int_t | size,
|  | magma_int_t | k,
|  | magma_queue_t | queue )

An efficient implementation of Blum, Floyd, Pratt, Rivest, and Tarjan's worst-case linear selection algorithm.

Derrick Coetzee, webma.nosp@m.ster.nosp@m.@moon.nosp@m.flar.nosp@m.e.com January 22, 2004 http://moonflare.com/code/select/select.pdf

Parameters

  [in,out] | a | float* array to select from
  [in] | size | magma_int_t size of array
  [in] | k | magma_int_t k-th smallest element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssolverinfo()

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_par | magma_s_solver_par* structure containing all solver information
  [in,out] | precond_par | magma_s_preconditioner* structure containing all preconditioner information
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssolverinfo_free()

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_par | magma_s_solver_par* structure containing all solver information
  [in,out] | precond_par | magma_s_preconditioner* structure containing all preconditioner information
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssolverinfo_init()

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_par | magma_s_solver_par* structure containing all solver information
  [in,out] | precond_par | magma_s_preconditioner* structure containing all preconditioner information
  [in] | queue | magma_queue_t Queue to execute in.

## magma_seigensolverinfo_init()

magma_int_t magma_seigensolverinfo_init | ( | magma_s_solver_par * | solver_par,
|  | magma_queue_t | queue )

Initializes space for eigensolvers.

Parameters

  [in,out] | solver_par | magma_s_solver_par* structure containing all solver information
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssort()

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] | x | float* array to sort
  [in] | first | magma_int_t pointer to first element
  [in] | last | magma_int_t pointer to last element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smsort()

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] | x | float* array to sort
  [in,out] | col | magma_index_t* Target array, will be modified during operation.
  [in,out] | row | magma_index_t* Target array, will be modified during operation.
  [in] | first | magma_int_t pointer to first element
  [in] | last | magma_int_t pointer to last element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sindexsort()

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] | x | magma_index_t* array to sort
  [in] | first | magma_int_t pointer to first element
  [in] | last | magma_int_t pointer to last element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sindexsortval()

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] | x | magma_index_t* array to sort
  [in,out] | y | float* array to sort
  [in] | first | magma_int_t pointer to first element
  [in] | last | magma_int_t pointer to last element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smorderstatistics()

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] | val | float* Target array, will be modified during operation.
  [in,out] | col | magma_index_t* Target array, will be modified during operation.
  [in,out] | row | magma_index_t* Target array, will be modified during operation.
  [in] | length | magma_int_t Length of the target array.
  [in] | k | magma_int_t Element to be identified (largest/smallest).
  [in] | r | magma_int_t rule how to sort: '1' -> largest, '0' -> smallest
  [out] | element | float* location of the respective element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sorderstatistics()

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] | val | float* Target array, will be modified during operation.
  [in] | length | magma_int_t Length of the target array.
  [in] | k | magma_int_t Element to be identified (largest/smallest).
  [in] | r | magma_int_t rule how to sort: '1' -> largest, '0' -> smallest
  [out] | element | float* location of the respective element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sorderstatistics_inc()

magma_int_t magma_sorderstatistics_inc | ( | float * | val,
|  | magma_int_t | length,
|  | magma_int_t | k,
|  | magma_int_t | inc,
|  | magma_int_t | r,
|  | float * | element,
|  | magma_queue_t | queue )

Approximates the k-th smallest element in an array by using order-statistics with step-size inc.

Parameters

  [in,out] | val | float* Target array, will be modified during operation.
  [in] | length | magma_int_t Length of the target array.
  [in] | k | magma_int_t Element to be identified (largest/smallest).
  [in] | inc | magma_int_t Stepsize in the approximation.
  [in] | r | magma_int_t rule how to sort: '1' -> largest, '0' -> smallest
  [out] | element | float* location of the respective element
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sbitonic_sort()

magma_int_t magma_sbitonic_sort | ( | magma_int_t | start,
|  | magma_int_t | length,
|  | float * | seq,
|  | magma_int_t | flag,
|  | magma_queue_t | queue )

Approximates the k-th smallest element in an array by using order-statistics with step-size inc.

Parameters

  [in] | start | magma_int_t Start position of the target array.
  [in] | length | magma_int_t Length of the target array.
  [in,out] | seq | float* Target array, will be modified during operation.
  [in] | flag | magma_int_t ???
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparse_opts()

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] | argc | int command line input
  [in] | argv | char** command line input
  [in,out] | opts | magma_sopts * magma solver options
  [out] | matrices | int counter how many linear systems to process
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svinit()

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] | x | magma_s_matrix* vector to initialize
  [in] | mem_loc | magma_location_t memory for vector
  [in] | num_rows | magma_int_t desired length of vector
  [in] | num_cols | magma_int_t desired width of vector-block (columns of dense matrix)
  [in] | values | float entries in vector
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svinit_rand()

magma_int_t magma_svinit_rand | ( | magma_s_matrix * | x,
|  | magma_location_t | mem_loc,
|  | magma_int_t | num_rows,
|  | magma_int_t | num_cols,
|  | magma_queue_t | queue )

Allocates memory for magma_s_matrix and initializes it with random values.

Parameters

  [out] | x | magma_s_matrix* vector to initialize
  [in] | mem_loc | magma_location_t memory for vector
  [in] | num_rows | magma_int_t desired length of vector
  [in] | num_cols | magma_int_t desired width of vector-block (columns of dense matrix)
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sprint_vector()

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] | x | magma_s_matrix vector to visualize
  [in] | offset | magma_int_t start inex of visualization
  [in] | visulen | magma_int_t number of entries to visualize
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svread()

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] | x | magma_s_matrix * vector to read in
  [in] | length | magma_int_t length of vector
  [in] | filename | char* file where vector is stored
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svspread()

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] | x | magma_s_matrix * vector to read in
  [in] | filename | char* file where vector is stored
  [in] | queue | magma_queue_t Queue to execute in.

## magma_swrite_vector()

magma_int_t magma_swrite_vector | ( | magma_s_matrix | A,
|  | const char * | filename,
|  | magma_queue_t | queue )

Writes a vector to a file.

Parameters

  [in] | A | magma_s_matrix matrix to write out
  [in] | filename | const char* output-filname of the mtx matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svset()

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] | m | magma_int_t number of rows
  [in] | n | magma_int_t number of columns
  [in] | val | float* array containing vector entries
  [out] | v | magma_s_matrix* magma vector
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svcopy()

magma_int_t magma_svcopy | ( | magma_s_matrix | v,
|  | magma_int_t * | m,
|  | magma_int_t * | n,
|  | float * | val,
|  | magma_queue_t | queue )

Passes a MAGMA vector back.

This function requires the array val to be already allocated (of size m x n).

Parameters

  [in] | v | magma_s_matrix magma vector
  [out] | m | magma_int_t number of rows
  [out] | n | magma_int_t number of columns
  [out] | val | float* array of size m x n the vector entries are copied into
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svset_dev()

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] | m | magma_int_t number of rows
  [in] | n | magma_int_t number of columns
  [in] | val | float* array containing vector entries
  [out] | v | magma_s_matrix* magma vector
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svget()

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] | v | magma_s_matrix magma vector
  [out] | m | magma_int_t number of rows
  [out] | n | magma_int_t number of columns
  [out] | val | float* array containing vector entries
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svget_dev()

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] | v | magma_s_matrix magma vector
  [out] | m | magma_int_t number of rows
  [out] | n | magma_int_t number of columns
  [out] | val | magmaFloat_ptr array containing vector entries
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svcopy_dev()

magma_int_t magma_svcopy_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).

This function requires the array val to be already allocated (of size m x n).

Parameters

  [in] | v | magma_s_matrix magma vector
  [out] | m | magma_int_t number of rows
  [out] | n | magma_int_t number of columns
  [out] | val | float* array of size m x n on the device the vector entries are copied into
  [in] | queue | magma_queue_t Queue to execute in.

## magma_svtranspose()

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] | x | magma_s_matrix input vector
  [out] | y | magma_s_matrix* output vector
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sdiagcheck()

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] | dA | magma_s_matrix matrix in CSR format
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smatrix_cup_gpu()

magma_int_t magma_smatrix_cup_gpu | ( | magma_s_matrix | A,
|  | magma_s_matrix | B,
|  | magma_s_matrix * | U,
|  | magma_queue_t | queue )

Generates a matrix \(U = A \cup B\).

If both matrices have a nonzero value in the same location, the value of A is used.

This is the GPU version of the operation.

Parameters

  [in] | A | magma_s_matrix Input matrix 1.
  [in] | B | magma_s_matrix Input matrix 2.
  [out] | U | magma_s_matrix* \(U = A \cup B\). If both matrices have a nonzero value in the same location, the value of A is used.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scsr_sort_gpu()

magma_int_t magma_scsr_sort_gpu | ( | magma_s_matrix * | A,
|  | magma_queue_t | queue )

Generates a matrix \(U = A \cup B\).

If both matrices have a nonzero value in the same location, the value of A is used.

This is the GPU version of the operation.

Parameters

  [in] | A | magma_s_matrix Input matrix 1.
  [in] | B | magma_s_matrix Input matrix 2.
  [out] | U | magma_s_matrix* \(U = A \cup B\). If both matrices have a nonzero value in the same location, the value of A is used.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smconjugate()

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] | A | magma_s_matrix* input/output matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smcsrcompressor_gpu()

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] | A | magma_s_matrix* input/output matrix
  [in] | queue | magma_queue_t Queue to execute in.

## magma_spreselect_gpu()

magma_int_t magma_spreselect_gpu | ( | magma_int_t | order,
|  | magma_s_matrix * | A,
|  | magma_s_matrix * | oneA,
|  | magma_queue_t | queue )

This function takes a list of candidates with residuals, and selects the largest in every row.

The output matrix only contains these largest elements (respectively a zero element if there is no candidate for a certain row).

Parameters

  [in] | order | magma_int_t order==0 lower triangular order==1 upper triangular
  [in] | A | magma_s_matrix* Matrix where elements are removed.
  [out] | oneA | magma_s_matrix* Matrix where elements are removed.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssampleselect()

magma_int_t magma_ssampleselect | ( | magma_int_t | total_size,
|  | magma_int_t | subset_size,
|  | float * | val,
|  | float * | thrs,
|  | magma_ptr * | tmp_ptr,
|  | magma_int_t * | tmp_size,
|  | magma_queue_t | queue )

This routine selects a threshold separating the subset_size smallest magnitude elements from the rest.

Parameters

  [in] | total_size | magma_int_t size of array val
  [in] | subset_size | magma_int_t number of smallest elements to separate
  [in] | val | float array containing the values
  [out] | thrs | float* computed threshold
  [in,out] | tmp_ptr | magma_ptr* pointer to pointer to temporary storage. May be reallocated during execution.
  [in,out] | tmp_size | magma_int_t* pointer to size of temporary storage. May be increased during execution.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssampleselect_approx()

magma_int_t magma_ssampleselect_approx | ( | magma_int_t | total_size,
|  | magma_int_t | subset_size,
|  | float * | val,
|  | float * | thrs,
|  | magma_ptr * | tmp_ptr,
|  | magma_int_t * | tmp_size,
|  | magma_queue_t | queue )

This routine selects an approximate threshold separating the subset_size smallest magnitude elements from the rest.

Parameters

  [in] | total_size | magma_int_t size of array val
  [in] | subset_size | magma_int_t number of smallest elements to separate
  [in] | val | float array containing the values
  [out] | thrs | float* computed threshold
  [in,out] | tmp_ptr | magma_ptr* pointer to pointer to temporary storage. May be reallocated during execution.
  [in,out] | tmp_size | magma_int_t* pointer to size of temporary storage. May be increased during execution.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssampleselect_nodp()

magma_int_t magma_ssampleselect_nodp | ( | magma_int_t | total_size,
|  | magma_int_t | subset_size,
|  | float * | val,
|  | float * | thrs,
|  | magma_ptr * | tmp_ptr,
|  | magma_int_t * | tmp_size,
|  | magma_queue_t | queue )

This routine selects a threshold separating the subset_size smallest magnitude elements from the rest.

This routine does not use dynamic parallelism (DP)

Parameters

  [in] | total_size | magma_int_t size of array val
  [in] | subset_size | magma_int_t number of smallest elements to separate
  [in] | val | float array containing the values
  [out] | thrs | float* computed threshold
  [in,out] | tmp_ptr | magma_ptr* pointer to pointer to temporary storage. May be reallocated during execution.
  [in,out] | tmp_size | magma_int_t* pointer to size of temporary storage. May be increased during execution.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_ssampleselect_approx_nodp()

magma_int_t magma_ssampleselect_approx_nodp | ( | magma_int_t | total_size,
|  | magma_int_t | subset_size,
|  | float * | val,
|  | float * | thrs,
|  | magma_ptr * | tmp_ptr,
|  | magma_int_t * | tmp_size,
|  | magma_queue_t | queue )

This routine selects an approximate threshold separating the subset_size smallest magnitude elements from the rest.

This routine does not use dynamic parallelism (DP)

Parameters

  [in] | total_size | magma_int_t size of array val
  [in] | subset_size | magma_int_t number of smallest elements to separate
  [in] | val | float array containing the values
  [out] | thrs | float* computed threshold
  [in,out] | tmp_ptr | magma_ptr* pointer to pointer to temporary storage. May be reallocated during execution.
  [in,out] | tmp_size | magma_int_t* pointer to size of temporary storage. May be increased during execution.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sisai_generator_regs()

magma_int_t magma_sisai_generator_regs | ( | magma_uplo_t | uplotype,
|  | magma_trans_t | transtype,
|  | magma_diag_t | diagtype,
|  | magma_s_matrix | L,
|  | magma_s_matrix * | M,
|  | magma_queue_t | queue )

This routine is designet to combine all kernels into one.

Parameters

  [in] | uplotype | magma_uplo_t lower or upper triangular
  [in] | transtype | magma_trans_t possibility for transposed matrix
  [in] | diagtype | magma_diag_t unit diagonal or not
  [in] | L | magma_s_matrix triangular factor for which the ISAI matrix is computed. Col-Major CSR storage.
  [in,out] | M | magma_s_matrix* SPAI preconditioner CSR col-major
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sgeisai_maxblock()

magma_int_t magma_sgeisai_maxblock | ( | magma_s_matrix | L,
|  | magma_s_matrix * | MT,
|  | magma_queue_t | queue )

This routine maximizes the pattern for the ISAI preconditioner.

Precisely, it computes L, L^2, L^3, L^4, L^5 and then selects the columns of M_L such that the nonzer-per-column are the lower max than the implementation-specific limit (32).

The input is the original matrix (row-major) The output is already col-major.

Parameters

  [in,out] | L | magma_s_matrix Incomplete factor.
  [in,out] | MT | magma_s_matrix* SPAI preconditioner structure, CSR col-major.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_smtrisolve_batched_gpu()

magma_int_t magma_smtrisolve_batched_gpu | ( | magma_uplo_t | uplotype,
|  | magma_trans_t | transtype,
|  | magma_diag_t | diagtype,
|  | magma_s_matrix | L,
|  | magma_s_matrix | LC,
|  | magma_index_t * | sizes,
|  | magma_index_t * | locations,
|  | float * | trisystems,
|  | float * | rhs,
|  | magma_queue_t | queue )

Does all triangular solves.

Parameters

  [in] | uplotype | magma_uplo_t lower or upper triangular
  [in] | transtype | magma_trans_t possibility for transposed matrix
  [in] | diagtype | magma_diag_t unit diagonal or not
  [in] | L | magma_s_matrix Matrix in CSR format
  [in] | LC | magma_s_matrix same matrix, also CSR, but col-major
  [out] | sizes | magma_int_t* Number of Elements that are replaced.
  [out] | locations | magma_int_t* Array indicating the locations.
  [out] | trisystems | float* trisystems
  [out] | rhs | float* right-hand sides
  [in] | queue | magma_queue_t Queue to execute in.

## magma_slobpcg_res()

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_rows | magma_int_t number of rows
  [in] | num_vecs | magma_int_t number of vectors
  [in] | evalues | magmaFloat_ptr array of eigenvalues/approximations
  [in] | X | magmaFloat_ptr block of eigenvector approximations
  [in] | R | magmaFloat_ptr block of residuals
  [in] | res | magmaFloat_ptr array of residuals
  [in] | queue | magma_queue_t Queue to execute in.

## magma_slobpcg_shift()

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_rows | magma_int_t number of rows
  [in] | num_vecs | magma_int_t number of vectors
  [in] | shift | magma_int_t shift number
  [in,out] | x | magmaFloat_ptr input/output vector x
  [in] | queue | magma_queue_t Queue to execute in.

## magma_sparilut_candidates_gpu()

magma_int_t magma_sparilut_candidates_gpu | ( | magma_s_matrix | L0,
|  | magma_s_matrix | U0,
|  | magma_s_matrix | L,
|  | magma_s_matrix | U,
|  | magma_s_matrix * | L_new,
|  | magma_s_matrix * | U_new,
|  | magma_queue_t | queue )

This function identifies the locations with a potential nonzero ILU residual R = A - L*U where L and U are the current incomplete factors.

Nonzero ILU residuals are possible 1 where A is nonzero but L and U have no nonzero entry 2 where the product L*U has fill-in but the location is not included in L or U

We assume that the incomplete factors are exact fro the elements included in the current pattern.

This is the GPU implementation of the candidate search.

2 GPU kernels are used: the first is a dry run assessing the memory need, the second then computes the candidate locations, the third eliminates float entries. The fourth kernel ensures the elements in a row are sorted for increasing column index.

Parameters

  [in] | L0 | magma_s_matrix tril(ILU(0) ) pattern of original system matrix.
  [in] | U0 | magma_s_matrix triu(ILU(0) ) pattern of original system matrix.
  [in] | L | magma_s_matrix Current lower triangular factor.
  [in] | U | magma_s_matrix Current upper triangular factor.
  [in,out] | L_new | magma_s_matrix* List of candidates for L in COO format.
  [in,out] | U_new | magma_s_matrix* List of candidates for U in COO format.
  [in] | queue | magma_queue_t Queue to execute in.

## magma_scopyscale()

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] | n | int length of v_i
  [in] | k | int

# skp entries v_i^T * r ( without r )

Parameters

  [in] | r | magmaFloat_ptr vector of length n
  [in] | v | magmaFloat_ptr vector of length n
  [in] | skp | magmaFloat_ptr array of parameters
  [in] | queue | magma_queue_t Queue to execute in.

## Variable Documentation

## val

US val

Removes any element with absolute value smaller thrs from the matrix.

It only uses the linked list and skips the ``removed'' elements

Parameters

  [in,out] | A | magma_s_matrix* Matrix where elements are removed.
  [in] | thrs | float* Threshold: all elements smaller are discarded
  [in] | queue | magma_queue_t Queue to execute in.

*******************************************************************************/

extern "C" magma_int_t magma_sparilut_thrsrm_semilinked( magma_s_matrix *U, magma_s_matrix *US, float *thrs, magma_queue_t queue ) { magma_int_t info = 0;

magma_s_matrix B={Magma_CSR}; B.num_rows = U->num_rows; B.num_cols = U->num_cols; B.storage_type = Magma_CSR; B.memory_location = Magma_CPU;

CHECK( magma_index_malloc_cpu( &B.row, U->num_rows+1 ) ); set col for values smaller threshold to -1

for( magma_int_t row=0; row<US->num_rows; row++){ magma_int_t i = US->row[row]; magma_int_t lasti=i; magma_int_t nexti=US->list[i]; while( nexti!=0 ){ if( MAGMA_S_ABS( US->val[ i ] ) < *thrs ){ if( US->row[row] == i ){ printf(" removed as first element in U rm: (%d,%d) at %d \n", row, US->col[ i ], i); fflush(stdout); US->row[row] = nexti; US->col[ i ] = -1; US->val[ i ] = MAGMA_S_ZERO; lasti=i; i = nexti; nexti = US->list[nexti]; } else{ printf(" removed in linked list in U rm: (%d,%d) at %d\n", row, US->col[ i ], i); fflush(stdout); US->list[lasti] = nexti; US->col[ i ] = -1; US->val[ i ] = MAGMA_S_ZERO; i = nexti; nexti = US->list[nexti]; } } else { lasti = i; i = nexti; nexti = US->list[nexti]; } } } /* printf("done\n");fflush(stdout);

get new rowpointer for U #pragma omp parallel for for( magma_int_t row=0; row<U->num_rows; row++){ magma_int_t loc_count = 0; for( magma_int_t i=U->row[row]; i<U->row[row+1]; i++ ){ if( U->col[i] > -1 ){ loc_count++;
} } B.row[row+1] = loc_count; }

new row pointer B.row[ 0 ] = 0; CHECK( magma_smatrix_createrowptr( B.num_rows, B.row, queue ) ); B.nnz = B.row[ B.num_rows ];

allocate new arrays CHECK( magma_smalloc_cpu( &B.val, U->nnz ) ); CHECK( magma_index_malloc_cpu( &B.rowidx, U->nnz ) ); CHECK( magma_index_malloc_cpu( &B.col, U->nnz ) );

#pragma omp parallel for for( magma_int_t row=0; row<U->num_rows; row++){ magma_index_t offset_old = U->row[row]; magma_index_t offset_new = B.row[row]; magma_index_t end_old = U->row[row+1]; magma_int_t count = 0; for(magma_int_t i=offset_old; i<end_old; i++){ if( U->col[i] > -1 ){ // copy this element B.col[ offset_new + count ] = U->col[i]; B.val[ offset_new + count ] = U->val[i]; B.rowidx[ offset_new + count ] = row; count++; } } } finally, swap the matrices CHECK( magma_smatrix_swap( &B, U, queue) );