jcuda.jcusparse
Class JCusparse2

java.lang.Object
  extended by jcuda.jcusparse.JCusparse2

public class JCusparse2
extends java.lang.Object

Java bindings for CUSPARSE, the NVIDIA CUDA sparse matrix BLAS library.


Method Summary
static int cusparseCaxpyi(cusparseHandle handle, int nnz, jcuda.Pointer alpha, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
           
static int cusparseCbsr2csr(cusparseHandle handle, int dirA, int mb, int nb, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseCbsrmv(cusparseHandle handle, int dirA, int transA, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseCbsrxmv(cusparseHandle handle, int dirA, int transA, int sizeOfMask, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrMaskPtrA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrEndPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseCcsc2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, jcuda.Pointer A, int lda)
           
static int cusparseCcsc2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseCcsr2bsr(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer bsrValC, jcuda.Pointer bsrRowPtrC, jcuda.Pointer bsrColIndC)
           
static int cusparseCcsr2csc(cusparseHandle handle, int m, int n, int nnz, jcuda.Pointer csrVal, jcuda.Pointer csrRowPtr, jcuda.Pointer csrColInd, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr, int copyValues, int idxBase)
           
static int cusparseCcsr2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer A, int lda)
           
static int cusparseCcsr2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseCcsrgeam(cusparseHandle handle, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer beta, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseCcsrgemm(cusparseHandle handle, int transA, int transB, int m, int n, int k, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseCcsric0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseCcsrilu0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseCcsrmm(cusparseHandle handle, int transA, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cusparseCcsrmm2(cusparseHandle handle, int transa, int transb, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cusparseCcsrmv(cusparseHandle handle, int transA, int m, int n, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseCcsrsm_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseCcsrsm_solve(cusparseHandle handle, int transA, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, int ldx, jcuda.Pointer y, int ldy)
           
static int cusparseCcsrsv_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseCcsrsv_solve(cusparseHandle handle, int transA, int m, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseCdense2csc(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerCol, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA)
           
static int cusparseCdense2csr(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
           
static int cusparseCdense2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseCdotci(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer resultDevHostPtr, int idxBase)
          Description: dot product of complex conjugate of a sparse vector x and a dense vector y.
static int cusparseCdoti(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer resultDevHostPtr, int idxBase)
           
static int cusparseCgthr(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
           
static int cusparseCgthrz(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
           
static int cusparseCgtsv_nopivot(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           
static int cusparseCgtsv(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           
static int cusparseCgtsvStridedBatch(cusparseHandle handle, int m, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer x, int batchCount, int batchStride)
           
static int cusparseChyb2csc(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr)
           
static int cusparseChyb2csr(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
           
static int cusparseChyb2dense(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer A, int lda)
           
static int cusparseChybmv(cusparseHandle handle, int transA, jcuda.Pointer alpha, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseChybsv_analysis(cusparseHandle handle, int transA, cusparseMatDescr descrA, cusparseHybMat hybA, cusparseSolveAnalysisInfo info)
           
static int cusparseChybsv_solve(cusparseHandle handle, int trans, jcuda.Pointer alpha, cusparseMatDescr descra, cusparseHybMat hybA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseCnnz(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRowCol, jcuda.Pointer nnzTotalDevHostPtr)
           
static int cusparseCreate(cusparseHandle handle)
          CUSPARSE initialization and managment routines
static int cusparseCreateHybMat(cusparseHybMat hybA)
          hybrid (HYB) format
static int cusparseCreateMatDescr(cusparseMatDescr descrA)
           When the matrix descriptor is created, its fields are initialized to: CUSPARSE_MATRIX_TYPE_GENERAL CUSPARSE_INDEX_BASE_ZERO All other fields are uninitialized
static int cusparseCreateSolveAnalysisInfo(cusparseSolveAnalysisInfo info)
          sparse traingular solve
static int cusparseCsctr(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
           
static int cusparseDaxpyi(cusparseHandle handle, int nnz, jcuda.Pointer alpha, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
           
static int cusparseDbsr2csr(cusparseHandle handle, int dirA, int mb, int nb, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseDbsrmv(cusparseHandle handle, int dirA, int transA, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseDbsrxmv(cusparseHandle handle, int dirA, int transA, int sizeOfMask, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrMaskPtrA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrEndPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseDcsc2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, jcuda.Pointer A, int lda)
           
static int cusparseDcsc2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseDcsr2bsr(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer bsrValC, jcuda.Pointer bsrRowPtrC, jcuda.Pointer bsrColIndC)
           
static int cusparseDcsr2csc(cusparseHandle handle, int m, int n, int nnz, jcuda.Pointer csrVal, jcuda.Pointer csrRowPtr, jcuda.Pointer csrColInd, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr, int copyValues, int idxBase)
           
static int cusparseDcsr2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer A, int lda)
           
static int cusparseDcsr2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseDcsrgeam(cusparseHandle handle, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer beta, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseDcsrgemm(cusparseHandle handle, int transA, int transB, int m, int n, int k, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseDcsric0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseDcsrilu0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseDcsrmm(cusparseHandle handle, int transA, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cusparseDcsrmm2(cusparseHandle handle, int transa, int transb, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cusparseDcsrmv(cusparseHandle handle, int transA, int m, int n, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseDcsrsm_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseDcsrsm_solve(cusparseHandle handle, int transA, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, int ldx, jcuda.Pointer y, int ldy)
           
static int cusparseDcsrsv_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseDcsrsv_solve(cusparseHandle handle, int transA, int m, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseDdense2csc(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerCol, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA)
           
static int cusparseDdense2csr(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
           
static int cusparseDdense2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseDdoti(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer resultDevHostPtr, int idxBase)
           
static int cusparseDestroy(cusparseHandle handle)
           
static int cusparseDestroyHybMat(cusparseHybMat hybA)
           
static int cusparseDestroyMatDescr(cusparseMatDescr descrA)
           
static int cusparseDestroySolveAnalysisInfo(cusparseSolveAnalysisInfo info)
           
static int cusparseDgthr(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
           
static int cusparseDgthrz(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
           
static int cusparseDgtsv_nopivot(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           
static int cusparseDgtsv(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           
static int cusparseDgtsvStridedBatch(cusparseHandle handle, int m, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer x, int batchCount, int batchStride)
           
static int cusparseDhyb2csc(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr)
           
static int cusparseDhyb2csr(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
           
static int cusparseDhyb2dense(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer A, int lda)
           
static int cusparseDhybmv(cusparseHandle handle, int transA, jcuda.Pointer alpha, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseDhybsv_analysis(cusparseHandle handle, int transA, cusparseMatDescr descrA, cusparseHybMat hybA, cusparseSolveAnalysisInfo info)
           
static int cusparseDhybsv_solve(cusparseHandle handle, int trans, jcuda.Pointer alpha, cusparseMatDescr descra, cusparseHybMat hybA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseDnnz(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRowCol, jcuda.Pointer nnzTotalDevHostPtr)
           
static int cusparseDroti(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer c, jcuda.Pointer s, int idxBase)
           
static int cusparseDsctr(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
           
static int cusparseGetLevelInfo(cusparseHandle handle, cusparseSolveAnalysisInfo info, int[] nlevels, jcuda.Pointer levelPtr, jcuda.Pointer levelInd)
           
static int cusparseGetMatDiagType(cusparseMatDescr descrA)
           
static int cusparseGetMatFillMode(cusparseMatDescr descrA)
           
static int cusparseGetMatIndexBase(cusparseMatDescr descrA)
           
static int cusparseGetMatType(cusparseMatDescr descrA)
           
static int cusparseGetPointerMode(cusparseHandle handle, int[] mode)
          CUSPARSE type creation, destruction, set and get routines
static int cusparseGetVersion(cusparseHandle handle, int[] version)
           
static int cusparseSaxpyi(cusparseHandle handle, int nnz, jcuda.Pointer alpha, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
          Description: Addition of a scalar multiple of a sparse vector x and a dense vector y.
static int cusparseSbsr2csr(cusparseHandle handle, int dirA, int mb, int nb, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
          Description: This routine converts a sparse matrix in BSR storage format to a sparse matrix in CSR storage format.
static int cusparseSbsrmv(cusparseHandle handle, int dirA, int transA, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
          Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in BSR storage format, x and y are dense vectors.
static int cusparseSbsrxmv(cusparseHandle handle, int dirA, int transA, int sizeOfMask, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrMaskPtrA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrEndPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
          Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in extended BSR storage format, x and y are dense vectors.
static int cusparseScsc2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, jcuda.Pointer A, int lda)
          Description: This routine converts a sparse matrix in CSC storage format to a dense matrix.
static int cusparseScsc2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, cusparseHybMat hybA, int userEllWidth, int partitionType)
          Description: This routine converts a sparse matrix in CSC storage format to a sparse matrix in HYB storage format.
static int cusparseScsr2bsr(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer bsrValC, jcuda.Pointer bsrRowPtrC, jcuda.Pointer bsrColIndC)
           
static int cusparseScsr2csc(cusparseHandle handle, int m, int n, int nnz, jcuda.Pointer csrVal, jcuda.Pointer csrRowPtr, jcuda.Pointer csrColInd, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr, int copyValues, int idxBase)
          Description: This routine converts a matrix from CSR to CSC sparse storage format.
static int cusparseScsr2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer A, int lda)
          Description: This routine converts a sparse matrix in CSR storage format to a dense matrix.
static int cusparseScsr2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseHybMat hybA, int userEllWidth, int partitionType)
          Description: This routine converts a sparse matrix in CSR storage format to a sparse matrix in HYB storage format.
static int cusparseScsrgeam(cusparseHandle handle, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer beta, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseScsrgemm(cusparseHandle handle, int transA, int transB, int m, int n, int k, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseScsric0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
          Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0) based on the information in the opaque structure info that was obtained from the analysis phase (csrsv_analysis).
static int cusparseScsrilu0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
          Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0) based on the information in the opaque structure info that was obtained from the analysis phase (csrsv_analysis).
static int cusparseScsrmm(cusparseHandle handle, int transA, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
          Description: Matrix-matrix multiplication C = alpha * op(A) * B + beta * C, where A is a sparse matrix, B and C are dense and usually tall matrices.
static int cusparseScsrmm2(cusparseHandle handle, int transa, int transb, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cusparseScsrmv(cusparseHandle handle, int transA, int m, int n, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
          Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in CSR storage format, x and y are dense vectors.
static int cusparseScsrsm_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
          Description: Solution of triangular linear system op(A) * Y = alpha * X, with multiple right-hand-sides, where A is a sparse matrix in CSR storage format, X and Y are dense and usually tall matrices.
static int cusparseScsrsm_solve(cusparseHandle handle, int transA, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, int ldx, jcuda.Pointer y, int ldy)
           
static int cusparseScsrsv_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
          Description: Solution of triangular linear system op(A) * y = alpha * x, where A is a sparse matrix in CSR storage format, x and y are dense vectors.
static int cusparseScsrsv_solve(cusparseHandle handle, int transA, int m, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseSdense2csc(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerCol, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA)
          Description: This routine converts a dense matrix to a sparse matrix in the CSC storage format, using the information computed by the nnz routine.
static int cusparseSdense2csr(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
          Description: This routine converts a dense matrix to a sparse matrix in the CSR storage format, using the information computed by the nnz routine.
static int cusparseSdense2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, cusparseHybMat hybA, int userEllWidth, int partitionType)
          Description: This routine converts a dense matrix to a sparse matrix in HYB storage format.
static int cusparseSdoti(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer resultDevHostPtr, int idxBase)
          Description: dot product of a sparse vector x and a dense vector y.
static int cusparseSetMatDiagType(cusparseMatDescr descrA, int diagType)
           
static int cusparseSetMatFillMode(cusparseMatDescr descrA, int fillMode)
           
static int cusparseSetMatIndexBase(cusparseMatDescr descrA, int base)
           
static int cusparseSetMatType(cusparseMatDescr descrA, int type)
           
static int cusparseSetPointerMode(cusparseHandle handle, int mode)
           
static int cusparseSetStream(cusparseHandle handle, jcuda.runtime.cudaStream_t streamId)
           
static int cusparseSgthr(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
          Description: Gather of non-zero elements from dense vector y into sparse vector x.
static int cusparseSgthrz(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
          Description: Gather of non-zero elements from desne vector y into sparse vector x (also replacing these elements in y by zeros).
static int cusparseSgtsv_nopivot(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           Description: Solution of tridiagonal linear system A * B = B, with multiple right-hand-sides.
static int cusparseSgtsv(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           Description: Solution of tridiagonal linear system A * B = B, with multiple right-hand-sides.
static int cusparseSgtsvStridedBatch(cusparseHandle handle, int m, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer x, int batchCount, int batchStride)
           Description: Solution of a set of tridiagonal linear systems A * x = x, each with a single right-hand-side.
static int cusparseShyb2csc(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr)
          Description: This routine converts a sparse matrix in HYB storage format to a sparse matrix in CSC storage format.
static int cusparseShyb2csr(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
          Description: This routine converts a sparse matrix in HYB storage format to a sparse matrix in CSR storage format.
static int cusparseShyb2dense(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer A, int lda)
          Description: This routine converts a sparse matrix in HYB storage format to a dense matrix.
static int cusparseShybmv(cusparseHandle handle, int transA, jcuda.Pointer alpha, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
          Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in HYB storage format, x and y are dense vectors.
static int cusparseShybsv_analysis(cusparseHandle handle, int transA, cusparseMatDescr descrA, cusparseHybMat hybA, cusparseSolveAnalysisInfo info)
          Description: Solution of triangular linear system op(A) * y = alpha * x, where A is a sparse matrix in HYB storage format, x and y are dense vectors.
static int cusparseShybsv_solve(cusparseHandle handle, int trans, jcuda.Pointer alpha, cusparseMatDescr descra, cusparseHybMat hybA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseSnnz(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRowCol, jcuda.Pointer nnzTotalDevHostPtr)
          Description: This routine finds the total number of non-zero elements and the number of non-zero elements per row or column in the dense matrix A.
static int cusparseSroti(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer c, jcuda.Pointer s, int idxBase)
          Description: Givens rotation, where c and s are cosine and sine, x and y are sparse and dense vectors, respectively.
static int cusparseSsctr(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
          Description: Scatter of elements of the sparse vector x into dense vector y.
static int cusparseXcoo2csr(cusparseHandle handle, jcuda.Pointer cooRowInd, int nnz, int m, jcuda.Pointer csrRowPtr, int idxBase)
          Description: This routine compresses the indecis of rows or columns.
static int cusparseXcsr2bsrNnz(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer bsrRowPtrC, jcuda.Pointer nnzTotalDevHostPtr)
          Description: This routine converts a sparse matrix in CSR storage format to a sparse matrix in BSR storage format.
static int cusparseXcsr2coo(cusparseHandle handle, jcuda.Pointer csrRowPtr, int nnz, int m, jcuda.Pointer cooRowInd, int idxBase)
          Description: This routine uncompresses the indecis of rows or columns.
static int cusparseXcsrgeamNnz(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrRowPtrC, jcuda.Pointer nnzTotalDevHostPtr)
          Description: This routine computes a sparse matrix that results from addition of two sparse matrices.
static int cusparseXcsrgemmNnz(cusparseHandle handle, int transA, int transB, int m, int n, int k, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrRowPtrC, jcuda.Pointer nnzTotalDevHostPtr)
          Description: This routine computes a sparse matrix that results from multiplication of two sparse matrices.
static int cusparseZaxpyi(cusparseHandle handle, int nnz, jcuda.Pointer alpha, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
           
static int cusparseZbsr2csr(cusparseHandle handle, int dirA, int mb, int nb, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseZbsrmv(cusparseHandle handle, int dirA, int transA, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseZbsrxmv(cusparseHandle handle, int dirA, int transA, int sizeOfMask, int mb, int nb, int nnzb, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer bsrValA, jcuda.Pointer bsrMaskPtrA, jcuda.Pointer bsrRowPtrA, jcuda.Pointer bsrEndPtrA, jcuda.Pointer bsrColIndA, int blockDim, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseZcsc2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, jcuda.Pointer A, int lda)
           
static int cusparseZcsc2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseZcsr2bsr(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, int blockDim, cusparseMatDescr descrC, jcuda.Pointer bsrValC, jcuda.Pointer bsrRowPtrC, jcuda.Pointer bsrColIndC)
           
static int cusparseZcsr2csc(cusparseHandle handle, int m, int n, int nnz, jcuda.Pointer csrVal, jcuda.Pointer csrRowPtr, jcuda.Pointer csrColInd, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr, int copyValues, int idxBase)
           
static int cusparseZcsr2dense(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer A, int lda)
           
static int cusparseZcsr2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseZcsrgeam(cusparseHandle handle, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer beta, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseZcsrgemm(cusparseHandle handle, int transA, int transB, int m, int n, int k, cusparseMatDescr descrA, int nnzA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseMatDescr descrB, int nnzB, jcuda.Pointer csrValB, jcuda.Pointer csrRowPtrB, jcuda.Pointer csrColIndB, cusparseMatDescr descrC, jcuda.Pointer csrValC, jcuda.Pointer csrRowPtrC, jcuda.Pointer csrColIndC)
           
static int cusparseZcsric0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseZcsrilu0(cusparseHandle handle, int trans, int m, cusparseMatDescr descrA, jcuda.Pointer csrValA_ValM, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseZcsrmm(cusparseHandle handle, int transA, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cusparseZcsrmm2(cusparseHandle handle, int transa, int transb, int m, int n, int k, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer B, int ldb, jcuda.Pointer beta, jcuda.Pointer C, int ldc)
           
static int cusparseZcsrmv(cusparseHandle handle, int transA, int m, int n, int nnz, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseZcsrsm_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseZcsrsm_solve(cusparseHandle handle, int transA, int m, int n, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, int ldx, jcuda.Pointer y, int ldy)
           
static int cusparseZcsrsv_analysis(cusparseHandle handle, int transA, int m, int nnz, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info)
           
static int cusparseZcsrsv_solve(cusparseHandle handle, int transA, int m, jcuda.Pointer alpha, cusparseMatDescr descrA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseZdense2csc(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerCol, jcuda.Pointer cscValA, jcuda.Pointer cscRowIndA, jcuda.Pointer cscColPtrA)
           
static int cusparseZdense2csr(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
           
static int cusparseZdense2hyb(cusparseHandle handle, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRow, cusparseHybMat hybA, int userEllWidth, int partitionType)
           
static int cusparseZdotci(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer resultDevHostPtr, int idxBase)
           
static int cusparseZdoti(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, jcuda.Pointer resultDevHostPtr, int idxBase)
           
static int cusparseZgthr(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
           
static int cusparseZgthrz(cusparseHandle handle, int nnz, jcuda.Pointer y, jcuda.Pointer xVal, jcuda.Pointer xInd, int idxBase)
           
static int cusparseZgtsv_nopivot(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           
static int cusparseZgtsv(cusparseHandle handle, int m, int n, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer B, int ldb)
           
static int cusparseZgtsvStridedBatch(cusparseHandle handle, int m, jcuda.Pointer dl, jcuda.Pointer d, jcuda.Pointer du, jcuda.Pointer x, int batchCount, int batchStride)
           
static int cusparseZhyb2csc(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer cscVal, jcuda.Pointer cscRowInd, jcuda.Pointer cscColPtr)
           
static int cusparseZhyb2csr(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer csrValA, jcuda.Pointer csrRowPtrA, jcuda.Pointer csrColIndA)
           
static int cusparseZhyb2dense(cusparseHandle handle, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer A, int lda)
           
static int cusparseZhybmv(cusparseHandle handle, int transA, jcuda.Pointer alpha, cusparseMatDescr descrA, cusparseHybMat hybA, jcuda.Pointer x, jcuda.Pointer beta, jcuda.Pointer y)
           
static int cusparseZhybsv_analysis(cusparseHandle handle, int transA, cusparseMatDescr descrA, cusparseHybMat hybA, cusparseSolveAnalysisInfo info)
           
static int cusparseZhybsv_solve(cusparseHandle handle, int trans, jcuda.Pointer alpha, cusparseMatDescr descra, cusparseHybMat hybA, cusparseSolveAnalysisInfo info, jcuda.Pointer x, jcuda.Pointer y)
           
static int cusparseZnnz(cusparseHandle handle, int dirA, int m, int n, cusparseMatDescr descrA, jcuda.Pointer A, int lda, jcuda.Pointer nnzPerRowCol, jcuda.Pointer nnzTotalDevHostPtr)
           
static int cusparseZsctr(cusparseHandle handle, int nnz, jcuda.Pointer xVal, jcuda.Pointer xInd, jcuda.Pointer y, int idxBase)
           
static void initialize()
          Initializes the native library.
static void setExceptionsEnabled(boolean enabled)
          Enables or disables exceptions.
static void setLogLevel(jcuda.LogLevel logLevel)
          Set the specified log level for the JCusparse library.
 
Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Method Detail

initialize

public static void initialize()
Initializes the native library. Note that this method does not have to be called explicitly, since it will be called automatically when this class is loaded.


setLogLevel

public static void setLogLevel(jcuda.LogLevel logLevel)
Set the specified log level for the JCusparse library.

Currently supported log levels:
LOG_QUIET: Never print anything
LOG_ERROR: Print error messages
LOG_TRACE: Print a trace of all native function calls

Parameters:
logLevel - The log level to use.

setExceptionsEnabled

public static void setExceptionsEnabled(boolean enabled)
Enables or disables exceptions. By default, the methods of this class only set the cusparseStatus from the native methods. If exceptions are enabled, a CudaException with a detailed error message will be thrown if a method is about to set a result code that is not cusparseStatus.CUSPARSE_STATUS_SUCCESS

Parameters:
enabled - Whether exceptions are enabled

cusparseCreate

public static int cusparseCreate(cusparseHandle handle)
CUSPARSE initialization and managment routines


cusparseDestroy

public static int cusparseDestroy(cusparseHandle handle)

cusparseGetVersion

public static int cusparseGetVersion(cusparseHandle handle,
                                     int[] version)

cusparseSetStream

public static int cusparseSetStream(cusparseHandle handle,
                                    jcuda.runtime.cudaStream_t streamId)

cusparseGetPointerMode

public static int cusparseGetPointerMode(cusparseHandle handle,
                                         int[] mode)
CUSPARSE type creation, destruction, set and get routines


cusparseSetPointerMode

public static int cusparseSetPointerMode(cusparseHandle handle,
                                         int mode)

cusparseCreateMatDescr

public static int cusparseCreateMatDescr(cusparseMatDescr descrA)
 When the matrix descriptor is created, its fields are initialized to:
       CUSPARSE_MATRIX_TYPE_GENERAL
       CUSPARSE_INDEX_BASE_ZERO
       All other fields are uninitialized
 


cusparseDestroyMatDescr

public static int cusparseDestroyMatDescr(cusparseMatDescr descrA)

cusparseSetMatType

public static int cusparseSetMatType(cusparseMatDescr descrA,
                                     int type)

cusparseGetMatType

public static int cusparseGetMatType(cusparseMatDescr descrA)

cusparseSetMatFillMode

public static int cusparseSetMatFillMode(cusparseMatDescr descrA,
                                         int fillMode)

cusparseGetMatFillMode

public static int cusparseGetMatFillMode(cusparseMatDescr descrA)

cusparseSetMatDiagType

public static int cusparseSetMatDiagType(cusparseMatDescr descrA,
                                         int diagType)

cusparseGetMatDiagType

public static int cusparseGetMatDiagType(cusparseMatDescr descrA)

cusparseSetMatIndexBase

public static int cusparseSetMatIndexBase(cusparseMatDescr descrA,
                                          int base)

cusparseGetMatIndexBase

public static int cusparseGetMatIndexBase(cusparseMatDescr descrA)

cusparseCreateSolveAnalysisInfo

public static int cusparseCreateSolveAnalysisInfo(cusparseSolveAnalysisInfo info)
sparse traingular solve


cusparseDestroySolveAnalysisInfo

public static int cusparseDestroySolveAnalysisInfo(cusparseSolveAnalysisInfo info)

cusparseGetLevelInfo

public static int cusparseGetLevelInfo(cusparseHandle handle,
                                       cusparseSolveAnalysisInfo info,
                                       int[] nlevels,
                                       jcuda.Pointer levelPtr,
                                       jcuda.Pointer levelInd)

cusparseCreateHybMat

public static int cusparseCreateHybMat(cusparseHybMat hybA)
hybrid (HYB) format


cusparseDestroyHybMat

public static int cusparseDestroyHybMat(cusparseHybMat hybA)

cusparseSaxpyi

public static int cusparseSaxpyi(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 jcuda.Pointer y,
                                 int idxBase)
Description: Addition of a scalar multiple of a sparse vector x and a dense vector y.


cusparseDaxpyi

public static int cusparseDaxpyi(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 jcuda.Pointer y,
                                 int idxBase)

cusparseCaxpyi

public static int cusparseCaxpyi(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 jcuda.Pointer y,
                                 int idxBase)

cusparseZaxpyi

public static int cusparseZaxpyi(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 jcuda.Pointer y,
                                 int idxBase)

cusparseSdoti

public static int cusparseSdoti(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                jcuda.Pointer resultDevHostPtr,
                                int idxBase)
Description: dot product of a sparse vector x and a dense vector y.


cusparseDdoti

public static int cusparseDdoti(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                jcuda.Pointer resultDevHostPtr,
                                int idxBase)

cusparseCdoti

public static int cusparseCdoti(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                jcuda.Pointer resultDevHostPtr,
                                int idxBase)

cusparseZdoti

public static int cusparseZdoti(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                jcuda.Pointer resultDevHostPtr,
                                int idxBase)

cusparseCdotci

public static int cusparseCdotci(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 jcuda.Pointer y,
                                 jcuda.Pointer resultDevHostPtr,
                                 int idxBase)
Description: dot product of complex conjugate of a sparse vector x and a dense vector y.


cusparseZdotci

public static int cusparseZdotci(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 jcuda.Pointer y,
                                 jcuda.Pointer resultDevHostPtr,
                                 int idxBase)

cusparseSgthr

public static int cusparseSgthr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer y,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                int idxBase)
Description: Gather of non-zero elements from dense vector y into sparse vector x.


cusparseDgthr

public static int cusparseDgthr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer y,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                int idxBase)

cusparseCgthr

public static int cusparseCgthr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer y,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                int idxBase)

cusparseZgthr

public static int cusparseZgthr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer y,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                int idxBase)

cusparseSgthrz

public static int cusparseSgthrz(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer y,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 int idxBase)
Description: Gather of non-zero elements from desne vector y into sparse vector x (also replacing these elements in y by zeros).


cusparseDgthrz

public static int cusparseDgthrz(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer y,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 int idxBase)

cusparseCgthrz

public static int cusparseCgthrz(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer y,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 int idxBase)

cusparseZgthrz

public static int cusparseZgthrz(cusparseHandle handle,
                                 int nnz,
                                 jcuda.Pointer y,
                                 jcuda.Pointer xVal,
                                 jcuda.Pointer xInd,
                                 int idxBase)

cusparseSsctr

public static int cusparseSsctr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                int idxBase)
Description: Scatter of elements of the sparse vector x into dense vector y.


cusparseDsctr

public static int cusparseDsctr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                int idxBase)

cusparseCsctr

public static int cusparseCsctr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                int idxBase)

cusparseZsctr

public static int cusparseZsctr(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                int idxBase)

cusparseSroti

public static int cusparseSroti(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                jcuda.Pointer c,
                                jcuda.Pointer s,
                                int idxBase)
Description: Givens rotation, where c and s are cosine and sine, x and y are sparse and dense vectors, respectively.


cusparseDroti

public static int cusparseDroti(cusparseHandle handle,
                                int nnz,
                                jcuda.Pointer xVal,
                                jcuda.Pointer xInd,
                                jcuda.Pointer y,
                                jcuda.Pointer c,
                                jcuda.Pointer s,
                                int idxBase)

cusparseScsrmv

public static int cusparseScsrmv(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in CSR storage format, x and y are dense vectors.


cusparseDcsrmv

public static int cusparseDcsrmv(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseCcsrmv

public static int cusparseCcsrmv(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseZcsrmv

public static int cusparseZcsrmv(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseShybmv

public static int cusparseShybmv(cusparseHandle handle,
                                 int transA,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 cusparseHybMat hybA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in HYB storage format, x and y are dense vectors.


cusparseDhybmv

public static int cusparseDhybmv(cusparseHandle handle,
                                 int transA,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 cusparseHybMat hybA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseChybmv

public static int cusparseChybmv(cusparseHandle handle,
                                 int transA,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 cusparseHybMat hybA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseZhybmv

public static int cusparseZhybmv(cusparseHandle handle,
                                 int transA,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 cusparseHybMat hybA,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseSbsrmv

public static int cusparseSbsrmv(cusparseHandle handle,
                                 int dirA,
                                 int transA,
                                 int mb,
                                 int nb,
                                 int nnzb,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer bsrValA,
                                 jcuda.Pointer bsrRowPtrA,
                                 jcuda.Pointer bsrColIndA,
                                 int blockDim,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in BSR storage format, x and y are dense vectors.


cusparseDbsrmv

public static int cusparseDbsrmv(cusparseHandle handle,
                                 int dirA,
                                 int transA,
                                 int mb,
                                 int nb,
                                 int nnzb,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer bsrValA,
                                 jcuda.Pointer bsrRowPtrA,
                                 jcuda.Pointer bsrColIndA,
                                 int blockDim,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseCbsrmv

public static int cusparseCbsrmv(cusparseHandle handle,
                                 int dirA,
                                 int transA,
                                 int mb,
                                 int nb,
                                 int nnzb,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer bsrValA,
                                 jcuda.Pointer bsrRowPtrA,
                                 jcuda.Pointer bsrColIndA,
                                 int blockDim,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseZbsrmv

public static int cusparseZbsrmv(cusparseHandle handle,
                                 int dirA,
                                 int transA,
                                 int mb,
                                 int nb,
                                 int nnzb,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer bsrValA,
                                 jcuda.Pointer bsrRowPtrA,
                                 jcuda.Pointer bsrColIndA,
                                 int blockDim,
                                 jcuda.Pointer x,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer y)

cusparseSbsrxmv

public static int cusparseSbsrxmv(cusparseHandle handle,
                                  int dirA,
                                  int transA,
                                  int sizeOfMask,
                                  int mb,
                                  int nb,
                                  int nnzb,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer bsrValA,
                                  jcuda.Pointer bsrMaskPtrA,
                                  jcuda.Pointer bsrRowPtrA,
                                  jcuda.Pointer bsrEndPtrA,
                                  jcuda.Pointer bsrColIndA,
                                  int blockDim,
                                  jcuda.Pointer x,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer y)
Description: Matrix-vector multiplication y = alpha * op(A) * x + beta * y, where A is a sparse matrix in extended BSR storage format, x and y are dense vectors.


cusparseDbsrxmv

public static int cusparseDbsrxmv(cusparseHandle handle,
                                  int dirA,
                                  int transA,
                                  int sizeOfMask,
                                  int mb,
                                  int nb,
                                  int nnzb,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer bsrValA,
                                  jcuda.Pointer bsrMaskPtrA,
                                  jcuda.Pointer bsrRowPtrA,
                                  jcuda.Pointer bsrEndPtrA,
                                  jcuda.Pointer bsrColIndA,
                                  int blockDim,
                                  jcuda.Pointer x,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer y)

cusparseCbsrxmv

public static int cusparseCbsrxmv(cusparseHandle handle,
                                  int dirA,
                                  int transA,
                                  int sizeOfMask,
                                  int mb,
                                  int nb,
                                  int nnzb,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer bsrValA,
                                  jcuda.Pointer bsrMaskPtrA,
                                  jcuda.Pointer bsrRowPtrA,
                                  jcuda.Pointer bsrEndPtrA,
                                  jcuda.Pointer bsrColIndA,
                                  int blockDim,
                                  jcuda.Pointer x,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer y)

cusparseZbsrxmv

public static int cusparseZbsrxmv(cusparseHandle handle,
                                  int dirA,
                                  int transA,
                                  int sizeOfMask,
                                  int mb,
                                  int nb,
                                  int nnzb,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer bsrValA,
                                  jcuda.Pointer bsrMaskPtrA,
                                  jcuda.Pointer bsrRowPtrA,
                                  jcuda.Pointer bsrEndPtrA,
                                  jcuda.Pointer bsrColIndA,
                                  int blockDim,
                                  jcuda.Pointer x,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer y)

cusparseScsrsv_analysis

public static int cusparseScsrsv_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)
Description: Solution of triangular linear system op(A) * y = alpha * x, where A is a sparse matrix in CSR storage format, x and y are dense vectors.


cusparseDcsrsv_analysis

public static int cusparseDcsrsv_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)

cusparseCcsrsv_analysis

public static int cusparseCcsrsv_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)

cusparseZcsrsv_analysis

public static int cusparseZcsrsv_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)

cusparseScsrsv_solve

public static int cusparseScsrsv_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseDcsrsv_solve

public static int cusparseDcsrsv_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseCcsrsv_solve

public static int cusparseCcsrsv_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseZcsrsv_solve

public static int cusparseZcsrsv_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseShybsv_analysis

public static int cusparseShybsv_analysis(cusparseHandle handle,
                                          int transA,
                                          cusparseMatDescr descrA,
                                          cusparseHybMat hybA,
                                          cusparseSolveAnalysisInfo info)
Description: Solution of triangular linear system op(A) * y = alpha * x, where A is a sparse matrix in HYB storage format, x and y are dense vectors.


cusparseDhybsv_analysis

public static int cusparseDhybsv_analysis(cusparseHandle handle,
                                          int transA,
                                          cusparseMatDescr descrA,
                                          cusparseHybMat hybA,
                                          cusparseSolveAnalysisInfo info)

cusparseChybsv_analysis

public static int cusparseChybsv_analysis(cusparseHandle handle,
                                          int transA,
                                          cusparseMatDescr descrA,
                                          cusparseHybMat hybA,
                                          cusparseSolveAnalysisInfo info)

cusparseZhybsv_analysis

public static int cusparseZhybsv_analysis(cusparseHandle handle,
                                          int transA,
                                          cusparseMatDescr descrA,
                                          cusparseHybMat hybA,
                                          cusparseSolveAnalysisInfo info)

cusparseShybsv_solve

public static int cusparseShybsv_solve(cusparseHandle handle,
                                       int trans,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descra,
                                       cusparseHybMat hybA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseChybsv_solve

public static int cusparseChybsv_solve(cusparseHandle handle,
                                       int trans,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descra,
                                       cusparseHybMat hybA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseDhybsv_solve

public static int cusparseDhybsv_solve(cusparseHandle handle,
                                       int trans,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descra,
                                       cusparseHybMat hybA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseZhybsv_solve

public static int cusparseZhybsv_solve(cusparseHandle handle,
                                       int trans,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descra,
                                       cusparseHybMat hybA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       jcuda.Pointer y)

cusparseScsrmm

public static int cusparseScsrmm(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int k,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer B,
                                 int ldb,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer C,
                                 int ldc)
Description: Matrix-matrix multiplication C = alpha * op(A) * B + beta * C, where A is a sparse matrix, B and C are dense and usually tall matrices.


cusparseDcsrmm

public static int cusparseDcsrmm(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int k,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer B,
                                 int ldb,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer C,
                                 int ldc)

cusparseCcsrmm

public static int cusparseCcsrmm(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int k,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer B,
                                 int ldb,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer C,
                                 int ldc)

cusparseZcsrmm

public static int cusparseZcsrmm(cusparseHandle handle,
                                 int transA,
                                 int m,
                                 int n,
                                 int k,
                                 int nnz,
                                 jcuda.Pointer alpha,
                                 cusparseMatDescr descrA,
                                 jcuda.Pointer csrValA,
                                 jcuda.Pointer csrRowPtrA,
                                 jcuda.Pointer csrColIndA,
                                 jcuda.Pointer B,
                                 int ldb,
                                 jcuda.Pointer beta,
                                 jcuda.Pointer C,
                                 int ldc)

cusparseScsrmm2

public static int cusparseScsrmm2(cusparseHandle handle,
                                  int transa,
                                  int transb,
                                  int m,
                                  int n,
                                  int k,
                                  int nnz,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  jcuda.Pointer B,
                                  int ldb,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer C,
                                  int ldc)

cusparseDcsrmm2

public static int cusparseDcsrmm2(cusparseHandle handle,
                                  int transa,
                                  int transb,
                                  int m,
                                  int n,
                                  int k,
                                  int nnz,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  jcuda.Pointer B,
                                  int ldb,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer C,
                                  int ldc)

cusparseCcsrmm2

public static int cusparseCcsrmm2(cusparseHandle handle,
                                  int transa,
                                  int transb,
                                  int m,
                                  int n,
                                  int k,
                                  int nnz,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  jcuda.Pointer B,
                                  int ldb,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer C,
                                  int ldc)

cusparseZcsrmm2

public static int cusparseZcsrmm2(cusparseHandle handle,
                                  int transa,
                                  int transb,
                                  int m,
                                  int n,
                                  int k,
                                  int nnz,
                                  jcuda.Pointer alpha,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  jcuda.Pointer B,
                                  int ldb,
                                  jcuda.Pointer beta,
                                  jcuda.Pointer C,
                                  int ldc)

cusparseScsrsm_analysis

public static int cusparseScsrsm_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)
Description: Solution of triangular linear system op(A) * Y = alpha * X, with multiple right-hand-sides, where A is a sparse matrix in CSR storage format, X and Y are dense and usually tall matrices.


cusparseDcsrsm_analysis

public static int cusparseDcsrsm_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)

cusparseCcsrsm_analysis

public static int cusparseCcsrsm_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)

cusparseZcsrsm_analysis

public static int cusparseZcsrsm_analysis(cusparseHandle handle,
                                          int transA,
                                          int m,
                                          int nnz,
                                          cusparseMatDescr descrA,
                                          jcuda.Pointer csrValA,
                                          jcuda.Pointer csrRowPtrA,
                                          jcuda.Pointer csrColIndA,
                                          cusparseSolveAnalysisInfo info)

cusparseScsrsm_solve

public static int cusparseScsrsm_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       int n,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       int ldx,
                                       jcuda.Pointer y,
                                       int ldy)

cusparseDcsrsm_solve

public static int cusparseDcsrsm_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       int n,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       int ldx,
                                       jcuda.Pointer y,
                                       int ldy)

cusparseCcsrsm_solve

public static int cusparseCcsrsm_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       int n,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       int ldx,
                                       jcuda.Pointer y,
                                       int ldy)

cusparseZcsrsm_solve

public static int cusparseZcsrsm_solve(cusparseHandle handle,
                                       int transA,
                                       int m,
                                       int n,
                                       jcuda.Pointer alpha,
                                       cusparseMatDescr descrA,
                                       jcuda.Pointer csrValA,
                                       jcuda.Pointer csrRowPtrA,
                                       jcuda.Pointer csrColIndA,
                                       cusparseSolveAnalysisInfo info,
                                       jcuda.Pointer x,
                                       int ldx,
                                       jcuda.Pointer y,
                                       int ldy)

cusparseScsrilu0

public static int cusparseScsrilu0(cusparseHandle handle,
                                   int trans,
                                   int m,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA_ValM,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseSolveAnalysisInfo info)
Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0) based on the information in the opaque structure info that was obtained from the analysis phase (csrsv_analysis).


cusparseDcsrilu0

public static int cusparseDcsrilu0(cusparseHandle handle,
                                   int trans,
                                   int m,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA_ValM,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseSolveAnalysisInfo info)

cusparseCcsrilu0

public static int cusparseCcsrilu0(cusparseHandle handle,
                                   int trans,
                                   int m,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA_ValM,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseSolveAnalysisInfo info)

cusparseZcsrilu0

public static int cusparseZcsrilu0(cusparseHandle handle,
                                   int trans,
                                   int m,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA_ValM,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseSolveAnalysisInfo info)

cusparseScsric0

public static int cusparseScsric0(cusparseHandle handle,
                                  int trans,
                                  int m,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA_ValM,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  cusparseSolveAnalysisInfo info)
Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0) based on the information in the opaque structure info that was obtained from the analysis phase (csrsv_analysis).


cusparseDcsric0

public static int cusparseDcsric0(cusparseHandle handle,
                                  int trans,
                                  int m,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA_ValM,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  cusparseSolveAnalysisInfo info)

cusparseCcsric0

public static int cusparseCcsric0(cusparseHandle handle,
                                  int trans,
                                  int m,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA_ValM,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  cusparseSolveAnalysisInfo info)

cusparseZcsric0

public static int cusparseZcsric0(cusparseHandle handle,
                                  int trans,
                                  int m,
                                  cusparseMatDescr descrA,
                                  jcuda.Pointer csrValA_ValM,
                                  jcuda.Pointer csrRowPtrA,
                                  jcuda.Pointer csrColIndA,
                                  cusparseSolveAnalysisInfo info)

cusparseSgtsv

public static int cusparseSgtsv(cusparseHandle handle,
                                int m,
                                int n,
                                jcuda.Pointer dl,
                                jcuda.Pointer d,
                                jcuda.Pointer du,
                                jcuda.Pointer B,
                                int ldb)
 Description: Solution of tridiagonal linear system A * B = B,
       with multiple right-hand-sides. The coefficient matrix A is 
       composed of lower (dl), main (d) and upper (du) diagonals, and 
 the right-hand-sides B are overwritten with the solution.
 


cusparseDgtsv

public static int cusparseDgtsv(cusparseHandle handle,
                                int m,
                                int n,
                                jcuda.Pointer dl,
                                jcuda.Pointer d,
                                jcuda.Pointer du,
                                jcuda.Pointer B,
                                int ldb)

cusparseCgtsv

public static int cusparseCgtsv(cusparseHandle handle,
                                int m,
                                int n,
                                jcuda.Pointer dl,
                                jcuda.Pointer d,
                                jcuda.Pointer du,
                                jcuda.Pointer B,
                                int ldb)

cusparseZgtsv

public static int cusparseZgtsv(cusparseHandle handle,
                                int m,
                                int n,
                                jcuda.Pointer dl,
                                jcuda.Pointer d,
                                jcuda.Pointer du,
                                jcuda.Pointer B,
                                int ldb)

cusparseSgtsv_nopivot

public static int cusparseSgtsv_nopivot(cusparseHandle handle,
                                        int m,
                                        int n,
                                        jcuda.Pointer dl,
                                        jcuda.Pointer d,
                                        jcuda.Pointer du,
                                        jcuda.Pointer B,
                                        int ldb)
 Description: Solution of tridiagonal linear system A * B = B,
       with multiple right-hand-sides. The coefficient matrix A is 
       composed of lower (dl), main (d) and upper (du) diagonals, and 
       the right-hand-sides B are overwritten with the solution. 
 These routines do not use pivoting, using a combination of PCR and CR algorithm
 


cusparseDgtsv_nopivot

public static int cusparseDgtsv_nopivot(cusparseHandle handle,
                                        int m,
                                        int n,
                                        jcuda.Pointer dl,
                                        jcuda.Pointer d,
                                        jcuda.Pointer du,
                                        jcuda.Pointer B,
                                        int ldb)

cusparseCgtsv_nopivot

public static int cusparseCgtsv_nopivot(cusparseHandle handle,
                                        int m,
                                        int n,
                                        jcuda.Pointer dl,
                                        jcuda.Pointer d,
                                        jcuda.Pointer du,
                                        jcuda.Pointer B,
                                        int ldb)

cusparseZgtsv_nopivot

public static int cusparseZgtsv_nopivot(cusparseHandle handle,
                                        int m,
                                        int n,
                                        jcuda.Pointer dl,
                                        jcuda.Pointer d,
                                        jcuda.Pointer du,
                                        jcuda.Pointer B,
                                        int ldb)

cusparseSgtsvStridedBatch

public static int cusparseSgtsvStridedBatch(cusparseHandle handle,
                                            int m,
                                            jcuda.Pointer dl,
                                            jcuda.Pointer d,
                                            jcuda.Pointer du,
                                            jcuda.Pointer x,
                                            int batchCount,
                                            int batchStride)
 Description: Solution of a set of tridiagonal linear systems
       A * x = x, each with a single right-hand-side. The coefficient 
       matrices A are composed of lower (dl), main (d) and upper (du) 
       diagonals and stored separated by a batchStride, while the 
 right-hand-sides x are also separated by a batchStride.
 


cusparseDgtsvStridedBatch

public static int cusparseDgtsvStridedBatch(cusparseHandle handle,
                                            int m,
                                            jcuda.Pointer dl,
                                            jcuda.Pointer d,
                                            jcuda.Pointer du,
                                            jcuda.Pointer x,
                                            int batchCount,
                                            int batchStride)

cusparseCgtsvStridedBatch

public static int cusparseCgtsvStridedBatch(cusparseHandle handle,
                                            int m,
                                            jcuda.Pointer dl,
                                            jcuda.Pointer d,
                                            jcuda.Pointer du,
                                            jcuda.Pointer x,
                                            int batchCount,
                                            int batchStride)

cusparseZgtsvStridedBatch

public static int cusparseZgtsvStridedBatch(cusparseHandle handle,
                                            int m,
                                            jcuda.Pointer dl,
                                            jcuda.Pointer d,
                                            jcuda.Pointer du,
                                            jcuda.Pointer x,
                                            int batchCount,
                                            int batchStride)

cusparseXcsrgemmNnz

public static int cusparseXcsrgemmNnz(cusparseHandle handle,
                                      int transA,
                                      int transB,
                                      int m,
                                      int n,
                                      int k,
                                      cusparseMatDescr descrA,
                                      int nnzA,
                                      jcuda.Pointer csrRowPtrA,
                                      jcuda.Pointer csrColIndA,
                                      cusparseMatDescr descrB,
                                      int nnzB,
                                      jcuda.Pointer csrRowPtrB,
                                      jcuda.Pointer csrColIndB,
                                      cusparseMatDescr descrC,
                                      jcuda.Pointer csrRowPtrC,
                                      jcuda.Pointer nnzTotalDevHostPtr)
Description: This routine computes a sparse matrix that results from multiplication of two sparse matrices.


cusparseScsrgemm

public static int cusparseScsrgemm(cusparseHandle handle,
                                   int transA,
                                   int transB,
                                   int m,
                                   int n,
                                   int k,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseDcsrgemm

public static int cusparseDcsrgemm(cusparseHandle handle,
                                   int transA,
                                   int transB,
                                   int m,
                                   int n,
                                   int k,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseCcsrgemm

public static int cusparseCcsrgemm(cusparseHandle handle,
                                   int transA,
                                   int transB,
                                   int m,
                                   int n,
                                   int k,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseZcsrgemm

public static int cusparseZcsrgemm(cusparseHandle handle,
                                   int transA,
                                   int transB,
                                   int m,
                                   int n,
                                   int k,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseXcsrgeamNnz

public static int cusparseXcsrgeamNnz(cusparseHandle handle,
                                      int m,
                                      int n,
                                      cusparseMatDescr descrA,
                                      int nnzA,
                                      jcuda.Pointer csrRowPtrA,
                                      jcuda.Pointer csrColIndA,
                                      cusparseMatDescr descrB,
                                      int nnzB,
                                      jcuda.Pointer csrRowPtrB,
                                      jcuda.Pointer csrColIndB,
                                      cusparseMatDescr descrC,
                                      jcuda.Pointer csrRowPtrC,
                                      jcuda.Pointer nnzTotalDevHostPtr)
Description: This routine computes a sparse matrix that results from addition of two sparse matrices.


cusparseScsrgeam

public static int cusparseScsrgeam(cusparseHandle handle,
                                   int m,
                                   int n,
                                   jcuda.Pointer alpha,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   jcuda.Pointer beta,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseDcsrgeam

public static int cusparseDcsrgeam(cusparseHandle handle,
                                   int m,
                                   int n,
                                   jcuda.Pointer alpha,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   jcuda.Pointer beta,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseCcsrgeam

public static int cusparseCcsrgeam(cusparseHandle handle,
                                   int m,
                                   int n,
                                   jcuda.Pointer alpha,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   jcuda.Pointer beta,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseZcsrgeam

public static int cusparseZcsrgeam(cusparseHandle handle,
                                   int m,
                                   int n,
                                   jcuda.Pointer alpha,
                                   cusparseMatDescr descrA,
                                   int nnzA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   jcuda.Pointer beta,
                                   cusparseMatDescr descrB,
                                   int nnzB,
                                   jcuda.Pointer csrValB,
                                   jcuda.Pointer csrRowPtrB,
                                   jcuda.Pointer csrColIndB,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseSnnz

public static int cusparseSnnz(cusparseHandle handle,
                               int dirA,
                               int m,
                               int n,
                               cusparseMatDescr descrA,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer nnzPerRowCol,
                               jcuda.Pointer nnzTotalDevHostPtr)
Description: This routine finds the total number of non-zero elements and the number of non-zero elements per row or column in the dense matrix A.


cusparseDnnz

public static int cusparseDnnz(cusparseHandle handle,
                               int dirA,
                               int m,
                               int n,
                               cusparseMatDescr descrA,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer nnzPerRowCol,
                               jcuda.Pointer nnzTotalDevHostPtr)

cusparseCnnz

public static int cusparseCnnz(cusparseHandle handle,
                               int dirA,
                               int m,
                               int n,
                               cusparseMatDescr descrA,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer nnzPerRowCol,
                               jcuda.Pointer nnzTotalDevHostPtr)

cusparseZnnz

public static int cusparseZnnz(cusparseHandle handle,
                               int dirA,
                               int m,
                               int n,
                               cusparseMatDescr descrA,
                               jcuda.Pointer A,
                               int lda,
                               jcuda.Pointer nnzPerRowCol,
                               jcuda.Pointer nnzTotalDevHostPtr)

cusparseSdense2csr

public static int cusparseSdense2csr(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA)
Description: This routine converts a dense matrix to a sparse matrix in the CSR storage format, using the information computed by the nnz routine.


cusparseDdense2csr

public static int cusparseDdense2csr(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA)

cusparseCdense2csr

public static int cusparseCdense2csr(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA)

cusparseZdense2csr

public static int cusparseZdense2csr(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA)

cusparseScsr2dense

public static int cusparseScsr2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA,
                                     jcuda.Pointer A,
                                     int lda)
Description: This routine converts a sparse matrix in CSR storage format to a dense matrix.


cusparseDcsr2dense

public static int cusparseDcsr2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseCcsr2dense

public static int cusparseCcsr2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseZcsr2dense

public static int cusparseZcsr2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer csrValA,
                                     jcuda.Pointer csrRowPtrA,
                                     jcuda.Pointer csrColIndA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseSdense2csc

public static int cusparseSdense2csc(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerCol,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA)
Description: This routine converts a dense matrix to a sparse matrix in the CSC storage format, using the information computed by the nnz routine.


cusparseDdense2csc

public static int cusparseDdense2csc(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerCol,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA)

cusparseCdense2csc

public static int cusparseCdense2csc(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerCol,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA)

cusparseZdense2csc

public static int cusparseZdense2csc(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerCol,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA)

cusparseScsc2dense

public static int cusparseScsc2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA,
                                     jcuda.Pointer A,
                                     int lda)
Description: This routine converts a sparse matrix in CSC storage format to a dense matrix.


cusparseDcsc2dense

public static int cusparseDcsc2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseCcsc2dense

public static int cusparseCcsc2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseZcsc2dense

public static int cusparseZcsc2dense(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer cscValA,
                                     jcuda.Pointer cscRowIndA,
                                     jcuda.Pointer cscColPtrA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseXcoo2csr

public static int cusparseXcoo2csr(cusparseHandle handle,
                                   jcuda.Pointer cooRowInd,
                                   int nnz,
                                   int m,
                                   jcuda.Pointer csrRowPtr,
                                   int idxBase)
Description: This routine compresses the indecis of rows or columns. It can be interpreted as a conversion from COO to CSR sparse storage format.


cusparseXcsr2coo

public static int cusparseXcsr2coo(cusparseHandle handle,
                                   jcuda.Pointer csrRowPtr,
                                   int nnz,
                                   int m,
                                   jcuda.Pointer cooRowInd,
                                   int idxBase)
Description: This routine uncompresses the indecis of rows or columns. It can be interpreted as a conversion from CSR to COO sparse storage format.


cusparseScsr2csc

public static int cusparseScsr2csc(cusparseHandle handle,
                                   int m,
                                   int n,
                                   int nnz,
                                   jcuda.Pointer csrVal,
                                   jcuda.Pointer csrRowPtr,
                                   jcuda.Pointer csrColInd,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr,
                                   int copyValues,
                                   int idxBase)
Description: This routine converts a matrix from CSR to CSC sparse storage format. The resulting matrix can be re-interpreted as a transpose of the original matrix in CSR storage format.


cusparseDcsr2csc

public static int cusparseDcsr2csc(cusparseHandle handle,
                                   int m,
                                   int n,
                                   int nnz,
                                   jcuda.Pointer csrVal,
                                   jcuda.Pointer csrRowPtr,
                                   jcuda.Pointer csrColInd,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr,
                                   int copyValues,
                                   int idxBase)

cusparseCcsr2csc

public static int cusparseCcsr2csc(cusparseHandle handle,
                                   int m,
                                   int n,
                                   int nnz,
                                   jcuda.Pointer csrVal,
                                   jcuda.Pointer csrRowPtr,
                                   jcuda.Pointer csrColInd,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr,
                                   int copyValues,
                                   int idxBase)

cusparseZcsr2csc

public static int cusparseZcsr2csc(cusparseHandle handle,
                                   int m,
                                   int n,
                                   int nnz,
                                   jcuda.Pointer csrVal,
                                   jcuda.Pointer csrRowPtr,
                                   jcuda.Pointer csrColInd,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr,
                                   int copyValues,
                                   int idxBase)

cusparseSdense2hyb

public static int cusparseSdense2hyb(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     cusparseHybMat hybA,
                                     int userEllWidth,
                                     int partitionType)
Description: This routine converts a dense matrix to a sparse matrix in HYB storage format.


cusparseDdense2hyb

public static int cusparseDdense2hyb(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     cusparseHybMat hybA,
                                     int userEllWidth,
                                     int partitionType)

cusparseCdense2hyb

public static int cusparseCdense2hyb(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     cusparseHybMat hybA,
                                     int userEllWidth,
                                     int partitionType)

cusparseZdense2hyb

public static int cusparseZdense2hyb(cusparseHandle handle,
                                     int m,
                                     int n,
                                     cusparseMatDescr descrA,
                                     jcuda.Pointer A,
                                     int lda,
                                     jcuda.Pointer nnzPerRow,
                                     cusparseHybMat hybA,
                                     int userEllWidth,
                                     int partitionType)

cusparseShyb2dense

public static int cusparseShyb2dense(cusparseHandle handle,
                                     cusparseMatDescr descrA,
                                     cusparseHybMat hybA,
                                     jcuda.Pointer A,
                                     int lda)
Description: This routine converts a sparse matrix in HYB storage format to a dense matrix.


cusparseDhyb2dense

public static int cusparseDhyb2dense(cusparseHandle handle,
                                     cusparseMatDescr descrA,
                                     cusparseHybMat hybA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseChyb2dense

public static int cusparseChyb2dense(cusparseHandle handle,
                                     cusparseMatDescr descrA,
                                     cusparseHybMat hybA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseZhyb2dense

public static int cusparseZhyb2dense(cusparseHandle handle,
                                     cusparseMatDescr descrA,
                                     cusparseHybMat hybA,
                                     jcuda.Pointer A,
                                     int lda)

cusparseScsr2hyb

public static int cusparseScsr2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)
Description: This routine converts a sparse matrix in CSR storage format to a sparse matrix in HYB storage format.


cusparseDcsr2hyb

public static int cusparseDcsr2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)

cusparseCcsr2hyb

public static int cusparseCcsr2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)

cusparseZcsr2hyb

public static int cusparseZcsr2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)

cusparseShyb2csr

public static int cusparseShyb2csr(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA)
Description: This routine converts a sparse matrix in HYB storage format to a sparse matrix in CSR storage format.


cusparseDhyb2csr

public static int cusparseDhyb2csr(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA)

cusparseChyb2csr

public static int cusparseChyb2csr(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA)

cusparseZhyb2csr

public static int cusparseZhyb2csr(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA)

cusparseScsc2hyb

public static int cusparseScsc2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer cscValA,
                                   jcuda.Pointer cscRowIndA,
                                   jcuda.Pointer cscColPtrA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)
Description: This routine converts a sparse matrix in CSC storage format to a sparse matrix in HYB storage format.


cusparseDcsc2hyb

public static int cusparseDcsc2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer cscValA,
                                   jcuda.Pointer cscRowIndA,
                                   jcuda.Pointer cscColPtrA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)

cusparseCcsc2hyb

public static int cusparseCcsc2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer cscValA,
                                   jcuda.Pointer cscRowIndA,
                                   jcuda.Pointer cscColPtrA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)

cusparseZcsc2hyb

public static int cusparseZcsc2hyb(cusparseHandle handle,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer cscValA,
                                   jcuda.Pointer cscRowIndA,
                                   jcuda.Pointer cscColPtrA,
                                   cusparseHybMat hybA,
                                   int userEllWidth,
                                   int partitionType)

cusparseShyb2csc

public static int cusparseShyb2csc(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr)
Description: This routine converts a sparse matrix in HYB storage format to a sparse matrix in CSC storage format.


cusparseDhyb2csc

public static int cusparseDhyb2csc(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr)

cusparseChyb2csc

public static int cusparseChyb2csc(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr)

cusparseZhyb2csc

public static int cusparseZhyb2csc(cusparseHandle handle,
                                   cusparseMatDescr descrA,
                                   cusparseHybMat hybA,
                                   jcuda.Pointer cscVal,
                                   jcuda.Pointer cscRowInd,
                                   jcuda.Pointer cscColPtr)

cusparseXcsr2bsrNnz

public static int cusparseXcsr2bsrNnz(cusparseHandle handle,
                                      int dirA,
                                      int m,
                                      int n,
                                      cusparseMatDescr descrA,
                                      jcuda.Pointer csrRowPtrA,
                                      jcuda.Pointer csrColIndA,
                                      int blockDim,
                                      cusparseMatDescr descrC,
                                      jcuda.Pointer bsrRowPtrC,
                                      jcuda.Pointer nnzTotalDevHostPtr)
Description: This routine converts a sparse matrix in CSR storage format to a sparse matrix in BSR storage format.


cusparseScsr2bsr

public static int cusparseScsr2bsr(cusparseHandle handle,
                                   int dirA,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer bsrValC,
                                   jcuda.Pointer bsrRowPtrC,
                                   jcuda.Pointer bsrColIndC)

cusparseDcsr2bsr

public static int cusparseDcsr2bsr(cusparseHandle handle,
                                   int dirA,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer bsrValC,
                                   jcuda.Pointer bsrRowPtrC,
                                   jcuda.Pointer bsrColIndC)

cusparseCcsr2bsr

public static int cusparseCcsr2bsr(cusparseHandle handle,
                                   int dirA,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer bsrValC,
                                   jcuda.Pointer bsrRowPtrC,
                                   jcuda.Pointer bsrColIndC)

cusparseZcsr2bsr

public static int cusparseZcsr2bsr(cusparseHandle handle,
                                   int dirA,
                                   int m,
                                   int n,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer csrValA,
                                   jcuda.Pointer csrRowPtrA,
                                   jcuda.Pointer csrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer bsrValC,
                                   jcuda.Pointer bsrRowPtrC,
                                   jcuda.Pointer bsrColIndC)

cusparseSbsr2csr

public static int cusparseSbsr2csr(cusparseHandle handle,
                                   int dirA,
                                   int mb,
                                   int nb,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer bsrValA,
                                   jcuda.Pointer bsrRowPtrA,
                                   jcuda.Pointer bsrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)
Description: This routine converts a sparse matrix in BSR storage format to a sparse matrix in CSR storage format.


cusparseDbsr2csr

public static int cusparseDbsr2csr(cusparseHandle handle,
                                   int dirA,
                                   int mb,
                                   int nb,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer bsrValA,
                                   jcuda.Pointer bsrRowPtrA,
                                   jcuda.Pointer bsrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseCbsr2csr

public static int cusparseCbsr2csr(cusparseHandle handle,
                                   int dirA,
                                   int mb,
                                   int nb,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer bsrValA,
                                   jcuda.Pointer bsrRowPtrA,
                                   jcuda.Pointer bsrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)

cusparseZbsr2csr

public static int cusparseZbsr2csr(cusparseHandle handle,
                                   int dirA,
                                   int mb,
                                   int nb,
                                   cusparseMatDescr descrA,
                                   jcuda.Pointer bsrValA,
                                   jcuda.Pointer bsrRowPtrA,
                                   jcuda.Pointer bsrColIndA,
                                   int blockDim,
                                   cusparseMatDescr descrC,
                                   jcuda.Pointer csrValC,
                                   jcuda.Pointer csrRowPtrC,
                                   jcuda.Pointer csrColIndC)