gaspersic/triton
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
a9d219cdf5689f95819c29b28eea7aef2a097575
triton/include/external/CUDA/cusparse.h
Philippe Tillet a9d219cdf5 [driver] added driver source code from isaac repository
2019-02-08 14:47:56 -05:00

6258 lines
359 KiB
C
Raw Blame History

/*
* Copyright 1993-2014 NVIDIA Corporation. All rights reserved.
*
* NOTICE TO LICENSEE:
*
* This source code and/or documentation ("Licensed Deliverables") are
* subject to NVIDIA intellectual property rights under U.S. and
* international Copyright laws.
*
* These Licensed Deliverables contained herein is PROPRIETARY and
* CONFIDENTIAL to NVIDIA and is being provided under the terms and
* conditions of a form of NVIDIA software license agreement by and
* between NVIDIA and Licensee ("License Agreement") or electronically
* accepted by Licensee. Notwithstanding any terms or conditions to
* the contrary in the License Agreement, reproduction or disclosure
* of the Licensed Deliverables to any third party without the express
* written consent of NVIDIA is prohibited.
*
* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
* LICENSE AGREEMENT, NVIDIA MAKES NO REPRESENTATION ABOUT THE
* SUITABILITY OF THESE LICENSED DELIVERABLES FOR ANY PURPOSE. IT IS
* PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY OF ANY KIND.
* NVIDIA DISCLAIMS ALL WARRANTIES WITH REGARD TO THESE LICENSED
* DELIVERABLES, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY,
* NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
* NOTWITHSTANDING ANY TERMS OR CONDITIONS TO THE CONTRARY IN THE
* LICENSE AGREEMENT, IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY
* SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, OR ANY
* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
* ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
* OF THESE LICENSED DELIVERABLES.
*
* U.S. Government End Users. These Licensed Deliverables are a
* "commercial item" as that term is defined at 48 C.F.R. 2.101 (OCT
* 1995), consisting of "commercial computer software" and "commercial
* computer software documentation" as such terms are used in 48
* C.F.R. 12.212 (SEPT 1995) and is provided to the U.S. Government
* only as a commercial end item. Consistent with 48 C.F.R.12.212 and
* 48 C.F.R. 227.7202-1 through 227.7202-4 (JUNE 1995), all
* U.S. Government End Users acquire the Licensed Deliverables with
* only those rights set forth herein.
*
* Any use of the Licensed Deliverables in individual and commercial
* software must include, in the user documentation and internal
* comments to the code, the above Disclaimer and U.S. Government End
* Users Notice.
*/
#if !defined(CUSPARSE_H_)
#define CUSPARSE_H_
#ifndef CUSPARSEAPI
#ifdef _WIN32
#define CUSPARSEAPI __stdcall
#else
#define CUSPARSEAPI
#endif
#endif
#include "driver_types.h"
#include "cuComplex.h" /* import complex data type */
#include "cuda_fp16.h"
#include "library_types.h"
#if defined(__cplusplus)
extern "C" {
#endif /* __cplusplus */
/* CUSPARSE status type returns */
typedef enum{
CUSPARSE_STATUS_SUCCESS=0,
CUSPARSE_STATUS_NOT_INITIALIZED=1,
CUSPARSE_STATUS_ALLOC_FAILED=2,
CUSPARSE_STATUS_INVALID_VALUE=3,
CUSPARSE_STATUS_ARCH_MISMATCH=4,
CUSPARSE_STATUS_MAPPING_ERROR=5,
CUSPARSE_STATUS_EXECUTION_FAILED=6,
CUSPARSE_STATUS_INTERNAL_ERROR=7,
CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED=8,
CUSPARSE_STATUS_ZERO_PIVOT=9
} cusparseStatus_t;
/* Opaque structure holding CUSPARSE library context */
struct cusparseContext;
typedef struct cusparseContext *cusparseHandle_t;
/* Opaque structure holding the matrix descriptor */
struct cusparseMatDescr;
typedef struct cusparseMatDescr *cusparseMatDescr_t;
/* Opaque structure holding the sparse triangular solve information */
struct cusparseSolveAnalysisInfo;
typedef struct cusparseSolveAnalysisInfo *cusparseSolveAnalysisInfo_t;
/* Opaque structures holding the sparse triangular solve information */
struct csrsv2Info;
typedef struct csrsv2Info *csrsv2Info_t;
struct bsrsv2Info;
typedef struct bsrsv2Info *bsrsv2Info_t;
struct bsrsm2Info;
typedef struct bsrsm2Info *bsrsm2Info_t;
/* Opaque structures holding incomplete Cholesky information */
struct csric02Info;
typedef struct csric02Info *csric02Info_t;
struct bsric02Info;
typedef struct bsric02Info *bsric02Info_t;
/* Opaque structures holding incomplete LU information */
struct csrilu02Info;
typedef struct csrilu02Info *csrilu02Info_t;
struct bsrilu02Info;
typedef struct bsrilu02Info *bsrilu02Info_t;
/* Opaque structures holding the hybrid (HYB) storage information */
struct cusparseHybMat;
typedef struct cusparseHybMat *cusparseHybMat_t;
/* Opaque structures holding sparse gemm information */
struct csrgemm2Info;
typedef struct csrgemm2Info *csrgemm2Info_t;
/* Opaque structure holding the sorting information */
struct csru2csrInfo;
typedef struct csru2csrInfo *csru2csrInfo_t;
/* Opaque structure holding the coloring information */
struct cusparseColorInfo;
typedef struct cusparseColorInfo *cusparseColorInfo_t;
/* Opaque structure holding the prune information */
struct pruneInfo;
typedef struct pruneInfo *pruneInfo_t;
/* Types definitions */
typedef enum {
CUSPARSE_POINTER_MODE_HOST = 0,
CUSPARSE_POINTER_MODE_DEVICE = 1
} cusparsePointerMode_t;
typedef enum {
CUSPARSE_ACTION_SYMBOLIC = 0,
CUSPARSE_ACTION_NUMERIC = 1
} cusparseAction_t;
typedef enum {
CUSPARSE_MATRIX_TYPE_GENERAL = 0,
CUSPARSE_MATRIX_TYPE_SYMMETRIC = 1,
CUSPARSE_MATRIX_TYPE_HERMITIAN = 2,
CUSPARSE_MATRIX_TYPE_TRIANGULAR = 3
} cusparseMatrixType_t;
typedef enum {
CUSPARSE_FILL_MODE_LOWER = 0,
CUSPARSE_FILL_MODE_UPPER = 1
} cusparseFillMode_t;
typedef enum {
CUSPARSE_DIAG_TYPE_NON_UNIT = 0,
CUSPARSE_DIAG_TYPE_UNIT = 1
} cusparseDiagType_t;
typedef enum {
CUSPARSE_INDEX_BASE_ZERO = 0,
CUSPARSE_INDEX_BASE_ONE = 1
} cusparseIndexBase_t;
typedef enum {
CUSPARSE_OPERATION_NON_TRANSPOSE = 0,
CUSPARSE_OPERATION_TRANSPOSE = 1,
CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE = 2
} cusparseOperation_t;
typedef enum {
CUSPARSE_DIRECTION_ROW = 0,
CUSPARSE_DIRECTION_COLUMN = 1
} cusparseDirection_t;
typedef enum {
CUSPARSE_HYB_PARTITION_AUTO = 0, // automatically decide how to split the data into regular/irregular part
CUSPARSE_HYB_PARTITION_USER = 1, // store data into regular part up to a user specified treshhold
CUSPARSE_HYB_PARTITION_MAX = 2 // store all data in the regular part
} cusparseHybPartition_t;
// used in csrsv2, csric02, and csrilu02
typedef enum {
CUSPARSE_SOLVE_POLICY_NO_LEVEL = 0, // no level information is generated, only reports structural zero.
CUSPARSE_SOLVE_POLICY_USE_LEVEL = 1
} cusparseSolvePolicy_t;
typedef enum {
CUSPARSE_SIDE_LEFT =0,
CUSPARSE_SIDE_RIGHT=1
} cusparseSideMode_t;
typedef enum {
CUSPARSE_COLOR_ALG0 = 0, // default
CUSPARSE_COLOR_ALG1 = 1
} cusparseColorAlg_t;
typedef enum {
CUSPARSE_ALG0 = 0, //default, naive
CUSPARSE_ALG1 = 1 //merge path
} cusparseAlgMode_t;
/* CUSPARSE initialization and managment routines */
cusparseStatus_t CUSPARSEAPI cusparseCreate(cusparseHandle_t *handle);
cusparseStatus_t CUSPARSEAPI cusparseDestroy(cusparseHandle_t handle);
cusparseStatus_t CUSPARSEAPI cusparseGetVersion(cusparseHandle_t handle, int *version);
cusparseStatus_t CUSPARSEAPI cusparseGetProperty(libraryPropertyType type, int *value);
cusparseStatus_t CUSPARSEAPI cusparseSetStream(cusparseHandle_t handle, cudaStream_t streamId);
cusparseStatus_t CUSPARSEAPI cusparseGetStream(cusparseHandle_t handle, cudaStream_t *streamId);
/* CUSPARSE type creation, destruction, set and get routines */
cusparseStatus_t CUSPARSEAPI cusparseGetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t *mode);
cusparseStatus_t CUSPARSEAPI cusparseSetPointerMode(cusparseHandle_t handle, cusparsePointerMode_t mode);
/* sparse matrix descriptor */
/* When the matrix descriptor is created, its fields are initialized to:
CUSPARSE_MATRIX_TYPE_GENERAL
CUSPARSE_INDEX_BASE_ZERO
All other fields are uninitialized
*/
cusparseStatus_t CUSPARSEAPI cusparseCreateMatDescr(cusparseMatDescr_t *descrA);
cusparseStatus_t CUSPARSEAPI cusparseDestroyMatDescr (cusparseMatDescr_t descrA);
cusparseStatus_t CUSPARSEAPI cusparseCopyMatDescr(cusparseMatDescr_t dest, const cusparseMatDescr_t src);
cusparseStatus_t CUSPARSEAPI cusparseSetMatType(cusparseMatDescr_t descrA, cusparseMatrixType_t type);
cusparseMatrixType_t CUSPARSEAPI cusparseGetMatType(const cusparseMatDescr_t descrA);
cusparseStatus_t CUSPARSEAPI cusparseSetMatFillMode(cusparseMatDescr_t descrA, cusparseFillMode_t fillMode);
cusparseFillMode_t CUSPARSEAPI cusparseGetMatFillMode(const cusparseMatDescr_t descrA);
cusparseStatus_t CUSPARSEAPI cusparseSetMatDiagType(cusparseMatDescr_t descrA, cusparseDiagType_t diagType);
cusparseDiagType_t CUSPARSEAPI cusparseGetMatDiagType(const cusparseMatDescr_t descrA);
cusparseStatus_t CUSPARSEAPI cusparseSetMatIndexBase(cusparseMatDescr_t descrA, cusparseIndexBase_t base);
cusparseIndexBase_t CUSPARSEAPI cusparseGetMatIndexBase(const cusparseMatDescr_t descrA);
/* sparse triangular solve and incomplete-LU and Cholesky (algorithm 1) */
cusparseStatus_t CUSPARSEAPI cusparseCreateSolveAnalysisInfo(cusparseSolveAnalysisInfo_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroySolveAnalysisInfo(cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseGetLevelInfo(cusparseHandle_t handle,
cusparseSolveAnalysisInfo_t info,
int *nlevels,
int **levelPtr,
int **levelInd);
/* sparse triangular solve (algorithm 2) */
cusparseStatus_t CUSPARSEAPI cusparseCreateCsrsv2Info(csrsv2Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrsv2Info(csrsv2Info_t info);
/* incomplete Cholesky (algorithm 2)*/
cusparseStatus_t CUSPARSEAPI cusparseCreateCsric02Info(csric02Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyCsric02Info(csric02Info_t info);
cusparseStatus_t CUSPARSEAPI cusparseCreateBsric02Info(bsric02Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyBsric02Info(bsric02Info_t info);
/* incomplete LU (algorithm 2) */
cusparseStatus_t CUSPARSEAPI cusparseCreateCsrilu02Info(csrilu02Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrilu02Info(csrilu02Info_t info);
cusparseStatus_t CUSPARSEAPI cusparseCreateBsrilu02Info(bsrilu02Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrilu02Info(bsrilu02Info_t info);
/* block-CSR triangular solve (algorithm 2) */
cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsv2Info(bsrsv2Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsv2Info(bsrsv2Info_t info);
cusparseStatus_t CUSPARSEAPI cusparseCreateBsrsm2Info(bsrsm2Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyBsrsm2Info(bsrsm2Info_t info);
/* hybrid (HYB) format */
cusparseStatus_t CUSPARSEAPI cusparseCreateHybMat(cusparseHybMat_t *hybA);
cusparseStatus_t CUSPARSEAPI cusparseDestroyHybMat(cusparseHybMat_t hybA);
/* sorting information */
cusparseStatus_t CUSPARSEAPI cusparseCreateCsru2csrInfo(csru2csrInfo_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyCsru2csrInfo(csru2csrInfo_t info);
/* coloring info */
cusparseStatus_t CUSPARSEAPI cusparseCreateColorInfo(cusparseColorInfo_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyColorInfo(cusparseColorInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseSetColorAlgs(cusparseColorInfo_t info, cusparseColorAlg_t alg);
cusparseStatus_t CUSPARSEAPI cusparseGetColorAlgs(cusparseColorInfo_t info, cusparseColorAlg_t *alg);
/* prune information */
cusparseStatus_t CUSPARSEAPI cusparseCreatePruneInfo(pruneInfo_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyPruneInfo(pruneInfo_t info);
/* --- Sparse Level 1 routines --- */
/* Description: Addition of a scalar multiple of a sparse vector x
and a dense vector y. */
cusparseStatus_t CUSPARSEAPI cusparseSaxpyi(cusparseHandle_t handle,
int nnz,
const float *alpha,
const float *xVal,
const int *xInd,
float *y,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseDaxpyi(cusparseHandle_t handle,
int nnz,
const double *alpha,
const double *xVal,
const int *xInd,
double *y,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseCaxpyi(cusparseHandle_t handle,
int nnz,
const cuComplex *alpha,
const cuComplex *xVal,
const int *xInd,
cuComplex *y,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseZaxpyi(cusparseHandle_t handle,
int nnz,
const cuDoubleComplex *alpha,
const cuDoubleComplex *xVal,
const int *xInd,
cuDoubleComplex *y,
cusparseIndexBase_t idxBase);
/* Description: dot product of a sparse vector x and a dense vector y. */
cusparseStatus_t CUSPARSEAPI cusparseSdoti(cusparseHandle_t handle,
int nnz,
const float *xVal,
const int *xInd,
const float *y,
float *resultDevHostPtr,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseDdoti(cusparseHandle_t handle,
int nnz,
const double *xVal,
const int *xInd,
const double *y,
double *resultDevHostPtr,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseCdoti(cusparseHandle_t handle,
int nnz,
const cuComplex *xVal,
const int *xInd,
const cuComplex *y,
cuComplex *resultDevHostPtr,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseZdoti(cusparseHandle_t handle,
int nnz,
const cuDoubleComplex *xVal,
const int *xInd,
const cuDoubleComplex *y,
cuDoubleComplex *resultDevHostPtr,
cusparseIndexBase_t idxBase);
/* Description: dot product of complex conjugate of a sparse vector x
and a dense vector y. */
cusparseStatus_t CUSPARSEAPI cusparseCdotci(cusparseHandle_t handle,
int nnz,
const cuComplex *xVal,
const int *xInd,
const cuComplex *y,
cuComplex *resultDevHostPtr,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseZdotci(cusparseHandle_t handle,
int nnz,
const cuDoubleComplex *xVal,
const int *xInd,
const cuDoubleComplex *y,
cuDoubleComplex *resultDevHostPtr,
cusparseIndexBase_t idxBase);
/* Description: Gather of non-zero elements from dense vector y into
sparse vector x. */
cusparseStatus_t CUSPARSEAPI cusparseSgthr(cusparseHandle_t handle,
int nnz,
const float *y,
float *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseDgthr(cusparseHandle_t handle,
int nnz,
const double *y,
double *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseCgthr(cusparseHandle_t handle,
int nnz,
const cuComplex *y,
cuComplex *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseZgthr(cusparseHandle_t handle,
int nnz,
const cuDoubleComplex *y,
cuDoubleComplex *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
/* Description: Gather of non-zero elements from desne vector y into
sparse vector x (also replacing these elements in y by zeros). */
cusparseStatus_t CUSPARSEAPI cusparseSgthrz(cusparseHandle_t handle,
int nnz,
float *y,
float *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseDgthrz(cusparseHandle_t handle,
int nnz,
double *y,
double *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseCgthrz(cusparseHandle_t handle,
int nnz,
cuComplex *y,
cuComplex *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseZgthrz(cusparseHandle_t handle,
int nnz,
cuDoubleComplex *y,
cuDoubleComplex *xVal,
const int *xInd,
cusparseIndexBase_t idxBase);
/* Description: Scatter of elements of the sparse vector x into
dense vector y. */
cusparseStatus_t CUSPARSEAPI cusparseSsctr(cusparseHandle_t handle,
int nnz,
const float *xVal,
const int *xInd,
float *y,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseDsctr(cusparseHandle_t handle,
int nnz,
const double *xVal,
const int *xInd,
double *y,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseCsctr(cusparseHandle_t handle,
int nnz,
const cuComplex *xVal,
const int *xInd,
cuComplex *y,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseZsctr(cusparseHandle_t handle,
int nnz,
const cuDoubleComplex *xVal,
const int *xInd,
cuDoubleComplex *y,
cusparseIndexBase_t idxBase);
/* Description: Givens rotation, where c and s are cosine and sine,
x and y are sparse and dense vectors, respectively. */
cusparseStatus_t CUSPARSEAPI cusparseSroti(cusparseHandle_t handle,
int nnz,
float *xVal,
const int *xInd,
float *y,
const float *c,
const float *s,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseDroti(cusparseHandle_t handle,
int nnz,
double *xVal,
const int *xInd,
double *y,
const double *c,
const double *s,
cusparseIndexBase_t idxBase);
/* --- Sparse Level 2 routines --- */
cusparseStatus_t CUSPARSEAPI cusparseSgemvi(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const float *alpha, /* host or device pointer */
const float *A,
int lda,
int nnz,
const float *xVal,
const int *xInd,
const float *beta, /* host or device pointer */
float *y,
cusparseIndexBase_t idxBase,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseSgemvi_bufferSize( cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
int *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDgemvi(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const double *alpha, /* host or device pointer */
const double *A,
int lda,
int nnz,
const double *xVal,
const int *xInd,
const double *beta, /* host or device pointer */
double *y,
cusparseIndexBase_t idxBase,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDgemvi_bufferSize( cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
int *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCgemvi(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A,
int lda,
int nnz,
const cuComplex *xVal,
const int *xInd,
const cuComplex *beta, /* host or device pointer */
cuComplex *y,
cusparseIndexBase_t idxBase,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCgemvi_bufferSize( cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
int *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZgemvi(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A,
int lda,
int nnz,
const cuDoubleComplex *xVal,
const int *xInd,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *y,
cusparseIndexBase_t idxBase,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZgemvi_bufferSize( cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
int *pBufferSize);
/* 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. */
cusparseStatus_t CUSPARSEAPI cusparseScsrmv(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const float *x,
const float *beta,
float *y);
cusparseStatus_t CUSPARSEAPI cusparseDcsrmv(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const double *x,
const double *beta,
double *y);
cusparseStatus_t CUSPARSEAPI cusparseCcsrmv(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuComplex *x,
const cuComplex *beta,
cuComplex *y);
cusparseStatus_t CUSPARSEAPI cusparseZcsrmv(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuDoubleComplex *x,
const cuDoubleComplex *beta,
cuDoubleComplex *y);
//Returns number of bytes
cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx_bufferSize(cusparseHandle_t handle,
cusparseAlgMode_t alg,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const void *alpha,
cudaDataType alphatype,
const cusparseMatDescr_t descrA,
const void *csrValA,
cudaDataType csrValAtype,
const int *csrRowPtrA,
const int *csrColIndA,
const void *x,
cudaDataType xtype,
const void *beta,
cudaDataType betatype,
void *y,
cudaDataType ytype,
cudaDataType executiontype,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCsrmvEx(cusparseHandle_t handle,
cusparseAlgMode_t alg,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const void *alpha,
cudaDataType alphatype,
const cusparseMatDescr_t descrA,
const void *csrValA,
cudaDataType csrValAtype,
const int *csrRowPtrA,
const int *csrColIndA,
const void *x,
cudaDataType xtype,
const void *beta,
cudaDataType betatype,
void *y,
cudaDataType ytype,
cudaDataType executiontype,
void* buffer);
/* 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
using a Merge Path load-balancing implementation. */
cusparseStatus_t CUSPARSEAPI cusparseScsrmv_mp(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const float *x,
const float *beta,
float *y);
cusparseStatus_t CUSPARSEAPI cusparseDcsrmv_mp(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const double *x,
const double *beta,
double *y);
cusparseStatus_t CUSPARSEAPI cusparseCcsrmv_mp(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuComplex *x,
const cuComplex *beta,
cuComplex *y);
cusparseStatus_t CUSPARSEAPI cusparseZcsrmv_mp(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int nnz,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuDoubleComplex *x,
const cuDoubleComplex *beta,
cuDoubleComplex *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. */
cusparseStatus_t CUSPARSEAPI cusparseShybmv(cusparseHandle_t handle,
cusparseOperation_t transA,
const float *alpha,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
const float *x,
const float *beta,
float *y);
cusparseStatus_t CUSPARSEAPI cusparseDhybmv(cusparseHandle_t handle,
cusparseOperation_t transA,
const double *alpha,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
const double *x,
const double *beta,
double *y);
cusparseStatus_t CUSPARSEAPI cusparseChybmv(cusparseHandle_t handle,
cusparseOperation_t transA,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
const cuComplex *x,
const cuComplex *beta,
cuComplex *y);
cusparseStatus_t CUSPARSEAPI cusparseZhybmv(cusparseHandle_t handle,
cusparseOperation_t transA,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
const cuDoubleComplex *x,
const cuDoubleComplex *beta,
cuDoubleComplex *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. */
cusparseStatus_t CUSPARSEAPI cusparseSbsrmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nb,
int nnzb,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const float *x,
const float *beta,
float *y);
cusparseStatus_t CUSPARSEAPI cusparseDbsrmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nb,
int nnzb,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const double *x,
const double *beta,
double *y);
cusparseStatus_t CUSPARSEAPI cusparseCbsrmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nb,
int nnzb,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cuComplex *x,
const cuComplex *beta,
cuComplex *y);
cusparseStatus_t CUSPARSEAPI cusparseZbsrmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nb,
int nnzb,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cuDoubleComplex *x,
const cuDoubleComplex *beta,
cuDoubleComplex *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. */
cusparseStatus_t CUSPARSEAPI cusparseSbsrxmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedMaskPtrA,
const int *bsrSortedRowPtrA,
const int *bsrSortedEndPtrA,
const int *bsrSortedColIndA,
int blockDim,
const float *x,
const float *beta,
float *y);
cusparseStatus_t CUSPARSEAPI cusparseDbsrxmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedMaskPtrA,
const int *bsrSortedRowPtrA,
const int *bsrSortedEndPtrA,
const int *bsrSortedColIndA,
int blockDim,
const double *x,
const double *beta,
double *y);
cusparseStatus_t CUSPARSEAPI cusparseCbsrxmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedMaskPtrA,
const int *bsrSortedRowPtrA,
const int *bsrSortedEndPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cuComplex *x,
const cuComplex *beta,
cuComplex *y);
cusparseStatus_t CUSPARSEAPI cusparseZbsrxmv(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int sizeOfMask,
int mb,
int nb,
int nnzb,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedMaskPtrA,
const int *bsrSortedRowPtrA,
const int *bsrSortedEndPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cuDoubleComplex *x,
const cuDoubleComplex *beta,
cuDoubleComplex *y);
/* Description: Solution of triangular linear system op(A) * x = alpha * f,
where A is a sparse matrix in CSR storage format, rhs f and solution x
are dense vectors. This routine implements algorithm 1 for the solve. */
cusparseStatus_t CUSPARSEAPI cusparseCsrsv_analysisEx(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const void *csrSortedValA,
cudaDataType csrSortedValAtype,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
cudaDataType executiontype);
cusparseStatus_t CUSPARSEAPI cusparseScsrsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseCsrsv_solveEx(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
const void *alpha,
cudaDataType alphatype,
const cusparseMatDescr_t descrA,
const void *csrSortedValA,
cudaDataType csrSortedValAtype,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const void *f,
cudaDataType ftype,
void *x,
cudaDataType xtype,
cudaDataType executiontype);
cusparseStatus_t CUSPARSEAPI cusparseScsrsv_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const float *f,
float *x);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const double *f,
double *x);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const cuComplex *f,
cuComplex *x);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const cuDoubleComplex *f,
cuDoubleComplex *x);
/* Description: Solution of triangular linear system op(A) * x = alpha * f,
where A is a sparse matrix in CSR storage format, rhs f and solution y
are dense vectors. This routine implements algorithm 1 for this problem.
Also, it provides a utility function to query size of buffer used. */
cusparseStatus_t CUSPARSEAPI cusparseXcsrsv2_zeroPivot(cusparseHandle_t handle,
csrsv2Info_t info,
int *position);
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSize(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSize(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSize(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSize(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseScsrsv2_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
const float *f,
float *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsv2_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
const double *f,
double *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsv2_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
const cuComplex *f,
cuComplex *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsv2_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrsv2Info_t info,
const cuDoubleComplex *f,
cuDoubleComplex *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
/* Description: Solution of triangular linear system op(A) * x = alpha * f,
where A is a sparse matrix in block-CSR storage format, rhs f and solution y
are dense vectors. This routine implements algorithm 2 for this problem.
Also, it provides a utility function to query size of buffer used. */
cusparseStatus_t CUSPARSEAPI cusparseXbsrsv2_zeroPivot(cusparseHandle_t handle,
bsrsv2Info_t info,
int *position);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockSize,
bsrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockSize,
bsrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockSize,
bsrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockSize,
bsrsv2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsv2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
const float *f,
float *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsv2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
const double *f,
double *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsv2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
const cuComplex *f,
cuComplex *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsv2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
int mb,
int nnzb,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
bsrsv2Info_t info,
const cuDoubleComplex *f,
cuDoubleComplex *x,
cusparseSolvePolicy_t policy,
void *pBuffer);
/* Description: Solution of triangular linear system op(A) * x = alpha * f,
where A is a sparse matrix in HYB storage format, rhs f and solution x
are dense vectors. */
cusparseStatus_t CUSPARSEAPI cusparseShybsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
const cusparseMatDescr_t descrA,
cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseDhybsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
const cusparseMatDescr_t descrA,
cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseChybsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
const cusparseMatDescr_t descrA,
cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseZhybsv_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
const cusparseMatDescr_t descrA,
cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseShybsv_solve(cusparseHandle_t handle,
cusparseOperation_t trans,
const float *alpha,
const cusparseMatDescr_t descra,
const cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info,
const float *f,
float *x);
cusparseStatus_t CUSPARSEAPI cusparseChybsv_solve(cusparseHandle_t handle,
cusparseOperation_t trans,
const cuComplex *alpha,
const cusparseMatDescr_t descra,
const cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info,
const cuComplex *f,
cuComplex *x);
cusparseStatus_t CUSPARSEAPI cusparseDhybsv_solve(cusparseHandle_t handle,
cusparseOperation_t trans,
const double *alpha,
const cusparseMatDescr_t descra,
const cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info,
const double *f,
double *x);
cusparseStatus_t CUSPARSEAPI cusparseZhybsv_solve(cusparseHandle_t handle,
cusparseOperation_t trans,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descra,
const cusparseHybMat_t hybA,
cusparseSolveAnalysisInfo_t info,
const cuDoubleComplex *f,
cuDoubleComplex *x);
/* --- Sparse Level 3 routines --- */
/* Description: sparse - dense matrix multiplication C = alpha * op(A) * B + beta * C,
where A is a sparse matrix in CSR format, B and C are dense tall matrices. */
cusparseStatus_t CUSPARSEAPI cusparseScsrmm(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int k,
int nnz,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const float *B,
int ldb,
const float *beta,
float *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseDcsrmm(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int k,
int nnz,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const double *B,
int ldb,
const double *beta,
double *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseCcsrmm(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int k,
int nnz,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuComplex *B,
int ldb,
const cuComplex *beta,
cuComplex *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseZcsrmm(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
int k,
int nnz,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuDoubleComplex *B,
int ldb,
const cuDoubleComplex *beta,
cuDoubleComplex *C,
int ldc);
/* Description: sparse - dense matrix multiplication C = alpha * op(A) * B + beta * C,
where A is a sparse matrix in CSR format, B and C are dense tall matrices.
This routine allows transposition of matrix B, which may improve performance. */
cusparseStatus_t CUSPARSEAPI cusparseScsrmm2(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
int nnz,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const float *B,
int ldb,
const float *beta,
float *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseDcsrmm2(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
int nnz,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const double *B,
int ldb,
const double *beta,
double *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseCcsrmm2(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
int nnz,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuComplex *B,
int ldb,
const cuComplex *beta,
cuComplex *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseZcsrmm2(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
int nnz,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuDoubleComplex *B,
int ldb,
const cuDoubleComplex *beta,
cuDoubleComplex *C,
int ldc);
/* Description: sparse - dense matrix multiplication C = alpha * op(A) * B + beta * C,
where A is a sparse matrix in block-CSR format, B and C are dense tall matrices.
This routine allows transposition of matrix B, which may improve performance. */
cusparseStatus_t CUSPARSEAPI cusparseSbsrmm(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int kb,
int nnzb,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
const int blockSize,
const float *B,
const int ldb,
const float *beta,
float *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseDbsrmm(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int kb,
int nnzb,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
const int blockSize,
const double *B,
const int ldb,
const double *beta,
double *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseCbsrmm(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int kb,
int nnzb,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
const int blockSize,
const cuComplex *B,
const int ldb,
const cuComplex *beta,
cuComplex *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseZbsrmm(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int kb,
int nnzb,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
const int blockSize,
const cuDoubleComplex *B,
const int ldb,
const cuDoubleComplex *beta,
cuDoubleComplex *C,
int ldc);
/* Description: dense - sparse matrix multiplication C = alpha * A * B + beta * C,
where A is column-major dense matrix, B is a sparse matrix in CSC format,
and C is column-major dense matrix. */
cusparseStatus_t CUSPARSEAPI cusparseSgemmi(cusparseHandle_t handle,
int m,
int n,
int k,
int nnz,
const float *alpha, /* host or device pointer */
const float *A,
int lda,
const float *cscValB,
const int *cscColPtrB,
const int *cscRowIndB,
const float *beta, /* host or device pointer */
float *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseDgemmi(cusparseHandle_t handle,
int m,
int n,
int k,
int nnz,
const double *alpha, /* host or device pointer */
const double *A,
int lda,
const double *cscValB,
const int *cscColPtrB,
const int *cscRowIndB,
const double *beta, /* host or device pointer */
double *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseCgemmi(cusparseHandle_t handle,
int m,
int n,
int k,
int nnz,
const cuComplex *alpha, /* host or device pointer */
const cuComplex *A,
int lda,
const cuComplex *cscValB,
const int *cscColPtrB,
const int *cscRowIndB,
const cuComplex *beta, /* host or device pointer */
cuComplex *C,
int ldc);
cusparseStatus_t CUSPARSEAPI cusparseZgemmi(cusparseHandle_t handle,
int m,
int n,
int k,
int nnz,
const cuDoubleComplex *alpha, /* host or device pointer */
const cuDoubleComplex *A,
int lda,
const cuDoubleComplex *cscValB,
const int *cscColPtrB,
const int *cscRowIndB,
const cuDoubleComplex *beta, /* host or device pointer */
cuDoubleComplex *C,
int ldc);
/* Description: Solution of triangular linear system op(A) * X = alpha * F,
with multiple right-hand-sides, where A is a sparse matrix in CSR storage
format, rhs F and solution X are dense tall matrices.
This routine implements algorithm 1 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseScsrsm_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsm_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsm_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsm_analysis(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseScsrsm_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const float *F,
int ldf,
float *X,
int ldx);
cusparseStatus_t CUSPARSEAPI cusparseDcsrsm_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const double *F,
int ldf,
double *X,
int ldx);
cusparseStatus_t CUSPARSEAPI cusparseCcsrsm_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const cuComplex *F,
int ldf,
cuComplex *X,
int ldx);
cusparseStatus_t CUSPARSEAPI cusparseZcsrsm_solve(cusparseHandle_t handle,
cusparseOperation_t transA,
int m,
int n,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
const cuDoubleComplex *F,
int ldf,
cuDoubleComplex *X,
int ldx);
/* Description: Solution of triangular linear system op(A) * X = alpha * F,
with multiple right-hand-sides, where A is a sparse matrix in CSR storage
format, rhs F and solution X are dense tall matrices.
This routine implements algorithm 2 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseXbsrsm2_zeroPivot(cusparseHandle_t handle,
bsrsm2Info_t info,
int *position);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transB,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
const float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
const double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseSbsrsm2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const float *alpha,
const cusparseMatDescr_t descrA,
const float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
const float *F,
int ldf,
float *X,
int ldx,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsrsm2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const double *alpha,
const cusparseMatDescr_t descrA,
const double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
const double *F,
int ldf,
double *X,
int ldx,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsrsm2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
const cuComplex *F,
int ldf,
cuComplex *X,
int ldx,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsrsm2_solve(cusparseHandle_t handle,
cusparseDirection_t dirA,
cusparseOperation_t transA,
cusparseOperation_t transXY,
int mb,
int n,
int nnzb,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrsm2Info_t info,
const cuDoubleComplex *F,
int ldf,
cuDoubleComplex *X,
int ldx,
cusparseSolvePolicy_t policy,
void *pBuffer);
/* --- Preconditioners --- */
/* Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv_analysis).
This routine implements algorithm 1 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseCsrilu0Ex(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
void *csrSortedValA_ValM,
cudaDataType csrSortedValA_ValMtype,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info,
cudaDataType executiontype);
cusparseStatus_t CUSPARSEAPI cusparseScsrilu0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
float *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseDcsrilu0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
double *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseCcsrilu0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseZcsrilu0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
/* Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv2_analysis).
This routine implements algorithm 2 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_numericBoost(cusparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double *tol,
float *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_numericBoost(cusparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double *tol,
double *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_numericBoost(cusparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double *tol,
cuComplex *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_numericBoost(cusparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double *tol,
cuDoubleComplex *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseXcsrilu02_zeroPivot(cusparseHandle_t handle,
csrilu02Info_t info,
int *position);
cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseScsrilu02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseScsrilu02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsrilu02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsrilu02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsrilu02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
/* Description: Compute the incomplete-LU factorization with 0 fill-in (ILU0)
of the matrix A stored in block-CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (bsrsv2_analysis).
This routine implements algorithm 2 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_numericBoost(cusparseHandle_t handle,
bsrilu02Info_t info,
int enable_boost,
double *tol,
float *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_numericBoost(cusparseHandle_t handle,
bsrilu02Info_t info,
int enable_boost,
double *tol,
double *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_numericBoost(cusparseHandle_t handle,
bsrilu02Info_t info,
int enable_boost,
double *tol,
cuComplex *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_numericBoost(cusparseHandle_t handle,
bsrilu02Info_t info,
int enable_boost,
double *tol,
cuDoubleComplex *boost_val);
cusparseStatus_t CUSPARSEAPI cusparseXbsrilu02_zeroPivot(cusparseHandle_t handle,
bsrilu02Info_t info,
int *position);
cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsrilu02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseSbsrilu02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descra,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsrilu02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descra,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsrilu02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descra,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsrilu02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descra,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsrilu02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
/* Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv_analysis).
This routine implements algorithm 1 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseScsric0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
float *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseDcsric0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
double *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseCcsric0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseZcsric0(cusparseHandle_t handle,
cusparseOperation_t trans,
int m,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA_ValM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseSolveAnalysisInfo_t info);
/* Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0)
of the matrix A stored in CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (csrsv2_analysis).
This routine implements algorithm 2 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseXcsric02_zeroPivot(cusparseHandle_t handle,
csric02Info_t info,
int *position);
cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSize(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseScsric02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDcsric02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCcsric02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZcsric02_bufferSizeExt(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
csric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseScsric02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsric02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsric02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsric02_analysis(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseScsric02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
float *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsric02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
double *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsric02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsric02(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrSortedValA_valM,
/* matrix A values are updated inplace
to be the preconditioner M values */
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
csric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
/* Description: Compute the incomplete-Cholesky factorization with 0 fill-in (IC0)
of the matrix A stored in block-CSR format based on the information in the opaque
structure info that was obtained from the analysis phase (bsrsv2_analysis).
This routine implements algorithm 1 for this problem. */
cusparseStatus_t CUSPARSEAPI cusparseXbsric02_zeroPivot(cusparseHandle_t handle,
bsric02Info_t info,
int *position);
cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSbsric02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDbsric02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCbsric02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZbsric02_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockSize,
bsric02Info_t info,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseSbsric02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pInputBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsric02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pInputBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsric02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pInputBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsric02_analysis(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pInputBuffer);
cusparseStatus_t CUSPARSEAPI cusparseSbsric02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDbsric02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCbsric02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZbsric02(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nnzb,
const cusparseMatDescr_t descrA,
cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int blockDim,
bsric02Info_t info,
cusparseSolvePolicy_t policy,
void *pBuffer);
/* Description: Solution of tridiagonal linear system A * X = F,
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 F are overwritten with the solution X.
These routine use pivoting. */
cusparseStatus_t CUSPARSEAPI cusparseSgtsv(
cusparseHandle_t handle,
int m,
int n,
const float *dl,
const float *d,
const float *du,
float *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv(
cusparseHandle_t handle,
int m,
int n,
const double *dl,
const double *d,
const double *du,
double *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv(
cusparseHandle_t handle,
int m,
int n,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
cuComplex *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv(
cusparseHandle_t handle,
int m,
int n,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
cuDoubleComplex *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const float *dl,
const float *d,
const float *du,
const float *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const double *dl,
const double *d,
const double *du,
const double *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
const cuComplex *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
const cuDoubleComplex *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSgtsv2(
cusparseHandle_t handle,
int m,
int n,
const float *dl,
const float *d,
const float *du,
float *B,
int ldb,
void* pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv2(
cusparseHandle_t handle,
int m,
int n,
const double *dl,
const double *d,
const double *du,
double *B,
int ldb,
void* pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv2(
cusparseHandle_t handle,
int m,
int n,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
cuComplex *B,
int ldb,
void* pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv2(
cusparseHandle_t handle,
int m,
int n,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
cuDoubleComplex *B,
int ldb,
void* pBuffer);
/* Description: Solution of tridiagonal linear system A * X = F,
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 F are overwritten with the solution X.
These routine does not use pivoting. */
cusparseStatus_t CUSPARSEAPI cusparseSgtsv_nopivot(
cusparseHandle_t handle,
int m,
int n,
const float *dl,
const float *d,
const float *du,
float *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv_nopivot(
cusparseHandle_t handle,
int m,
int n,
const double *dl,
const double *d,
const double *du,
double *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv_nopivot(
cusparseHandle_t handle,
int m,
int n,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
cuComplex *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv_nopivot(
cusparseHandle_t handle,
int m,
int n,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
cuDoubleComplex *B,
int ldb);
cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const float *dl,
const float *d,
const float *du,
const float *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const double *dl,
const double *d,
const double *du,
const double *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
const cuComplex *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
const cuDoubleComplex *B,
int ldb,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSgtsv2_nopivot(
cusparseHandle_t handle,
int m,
int n,
const float *dl,
const float *d,
const float *du,
float *B,
int ldb,
void* pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv2_nopivot(
cusparseHandle_t handle,
int m,
int n,
const double *dl,
const double *d,
const double *du,
double *B,
int ldb,
void* pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv2_nopivot(
cusparseHandle_t handle,
int m,
int n,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
cuComplex *B,
int ldb,
void* pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv2_nopivot(
cusparseHandle_t handle,
int m,
int n,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
cuDoubleComplex *B,
int ldb,
void* pBuffer);
/* Description: Solution of a set of tridiagonal linear systems
A_{i} * x_{i} = f_{i} for i=1,...,batchCount. The coefficient
matrices A_{i} are composed of lower (dl), main (d) and upper (du)
diagonals and stored separated by a batchStride. Also, the
right-hand-sides/solutions f_{i}/x_{i} are separated by a batchStride. */
cusparseStatus_t CUSPARSEAPI cusparseSgtsvStridedBatch(
cusparseHandle_t handle,
int m,
const float *dl,
const float *d,
const float *du,
float *x,
int batchCount,
int batchStride);
cusparseStatus_t CUSPARSEAPI cusparseDgtsvStridedBatch(
cusparseHandle_t handle,
int m,
const double *dl,
const double *d,
const double *du,
double *x,
int batchCount,
int batchStride);
cusparseStatus_t CUSPARSEAPI cusparseCgtsvStridedBatch(
cusparseHandle_t handle,
int m,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
cuComplex *x,
int batchCount,
int batchStride);
cusparseStatus_t CUSPARSEAPI cusparseZgtsvStridedBatch(
cusparseHandle_t handle,
int m,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
cuDoubleComplex *x,
int batchCount,
int batchStride);
cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch_bufferSizeExt(
cusparseHandle_t handle,
int m,
const float *dl,
const float *d,
const float *du,
const float *x,
int batchCount,
int batchStride,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv2StridedBatch_bufferSizeExt(
cusparseHandle_t handle,
int m,
const double *dl,
const double *d,
const double *du,
const double *x,
int batchCount,
int batchStride,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch_bufferSizeExt(
cusparseHandle_t handle,
int m,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
const cuComplex *x,
int batchCount,
int batchStride,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch_bufferSizeExt(
cusparseHandle_t handle,
int m,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
const cuDoubleComplex *x,
int batchCount,
int batchStride,
size_t *bufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSgtsv2StridedBatch(
cusparseHandle_t handle,
int m,
const float *dl,
const float *d,
const float *du,
float *x,
int batchCount,
int batchStride,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDgtsv2StridedBatch(
cusparseHandle_t handle,
int m,
const double *dl,
const double *d,
const double *du,
double *x,
int batchCount,
int batchStride,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCgtsv2StridedBatch(
cusparseHandle_t handle,
int m,
const cuComplex *dl,
const cuComplex *d,
const cuComplex *du,
cuComplex *x,
int batchCount,
int batchStride,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZgtsv2StridedBatch(
cusparseHandle_t handle,
int m,
const cuDoubleComplex *dl,
const cuDoubleComplex *d,
const cuDoubleComplex *du,
cuDoubleComplex *x,
int batchCount,
int batchStride,
void *pBuffer);
/* --- Sparse Level 4 routines --- */
/* Description: Compute sparse - sparse matrix multiplication for matrices
stored in CSR format. */
cusparseStatus_t CUSPARSEAPI cusparseXcsrgemmNnz(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
const cusparseMatDescr_t descrA,
const int nnzA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
const int nnzB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
int *csrSortedRowPtrC,
int *nnzTotalDevHostPtr);
cusparseStatus_t CUSPARSEAPI cusparseScsrgemm(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
const cusparseMatDescr_t descrA,
const int nnzA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
const int nnzB,
const float *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
float *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
const cusparseMatDescr_t descrA,
int nnzA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const double *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
double *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
const cusparseMatDescr_t descrA,
int nnzA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const cuComplex *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
cuComplex *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm(cusparseHandle_t handle,
cusparseOperation_t transA,
cusparseOperation_t transB,
int m,
int n,
int k,
const cusparseMatDescr_t descrA,
int nnzA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const cuDoubleComplex *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
cuDoubleComplex *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC);
/* Description: Compute sparse - sparse matrix multiplication for matrices
stored in CSR format. */
cusparseStatus_t CUSPARSEAPI cusparseCreateCsrgemm2Info(csrgemm2Info_t *info);
cusparseStatus_t CUSPARSEAPI cusparseDestroyCsrgemm2Info(csrgemm2Info_t info);
cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int k,
const float *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const float *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
csrgemm2Info_t info,
size_t *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int k,
const double *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const double *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
csrgemm2Info_t info,
size_t *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int k,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cuComplex *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
csrgemm2Info_t info,
size_t *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int k,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cuDoubleComplex *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
csrgemm2Info_t info,
size_t *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseXcsrgemm2Nnz(cusparseHandle_t handle,
int m,
int n,
int k,
const cusparseMatDescr_t descrA,
int nnzA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrD,
int nnzD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
const cusparseMatDescr_t descrC,
int *csrSortedRowPtrC,
int *nnzTotalDevHostPtr,
const csrgemm2Info_t info,
void *pBuffer );
cusparseStatus_t CUSPARSEAPI cusparseScsrgemm2(cusparseHandle_t handle,
int m,
int n,
int k,
const float *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const float *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const float *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const float *csrSortedValD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
const cusparseMatDescr_t descrC,
float *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC,
const csrgemm2Info_t info,
void *pBuffer );
cusparseStatus_t CUSPARSEAPI cusparseDcsrgemm2(cusparseHandle_t handle,
int m,
int n,
int k,
const double *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const double *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const double *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const double *csrSortedValD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
const cusparseMatDescr_t descrC,
double *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC,
const csrgemm2Info_t info,
void *pBuffer );
cusparseStatus_t CUSPARSEAPI cusparseCcsrgemm2(cusparseHandle_t handle,
int m,
int n,
int k,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const cuComplex *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cuComplex *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const cuComplex *csrSortedValD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
const cusparseMatDescr_t descrC,
cuComplex *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC,
const csrgemm2Info_t info,
void *pBuffer );
cusparseStatus_t CUSPARSEAPI cusparseZcsrgemm2(cusparseHandle_t handle,
int m,
int n,
int k,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const cuDoubleComplex *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cuDoubleComplex *beta,
const cusparseMatDescr_t descrD,
int nnzD,
const cuDoubleComplex *csrSortedValD,
const int *csrSortedRowPtrD,
const int *csrSortedColIndD,
const cusparseMatDescr_t descrC,
cuDoubleComplex *csrSortedValC,
const int *csrSortedRowPtrC,
int *csrSortedColIndC,
const csrgemm2Info_t info,
void *pBuffer );
/* Description: Compute sparse - sparse matrix addition of matrices
stored in CSR format */
cusparseStatus_t CUSPARSEAPI cusparseXcsrgeamNnz(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
int nnzA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrB,
int nnzB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
int *csrSortedRowPtrC,
int *nnzTotalDevHostPtr);
cusparseStatus_t CUSPARSEAPI cusparseScsrgeam(cusparseHandle_t handle,
int m,
int n,
const float *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const float *beta,
const cusparseMatDescr_t descrB,
int nnzB,
const float *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
float *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseDcsrgeam(cusparseHandle_t handle,
int m,
int n,
const double *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const double *beta,
const cusparseMatDescr_t descrB,
int nnzB,
const double *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
double *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseCcsrgeam(cusparseHandle_t handle,
int m,
int n,
const cuComplex *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuComplex *beta,
const cusparseMatDescr_t descrB,
int nnzB,
const cuComplex *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
cuComplex *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseZcsrgeam(cusparseHandle_t handle,
int m,
int n,
const cuDoubleComplex *alpha,
const cusparseMatDescr_t descrA,
int nnzA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cuDoubleComplex *beta,
const cusparseMatDescr_t descrB,
int nnzB,
const cuDoubleComplex *csrSortedValB,
const int *csrSortedRowPtrB,
const int *csrSortedColIndB,
const cusparseMatDescr_t descrC,
cuDoubleComplex *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
/* --- Sparse Matrix Reorderings --- */
/* Description: Find an approximate coloring of a matrix stored in CSR format. */
cusparseStatus_t CUSPARSEAPI cusparseScsrcolor(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const float *fractionToColor,
int *ncolors,
int *coloring,
int *reordering,
const cusparseColorInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseDcsrcolor(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const double *fractionToColor,
int *ncolors,
int *coloring,
int *reordering,
const cusparseColorInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseCcsrcolor(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const float *fractionToColor,
int *ncolors,
int *coloring,
int *reordering,
const cusparseColorInfo_t info);
cusparseStatus_t CUSPARSEAPI cusparseZcsrcolor(cusparseHandle_t handle,
int m,
int nnz,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const double *fractionToColor,
int *ncolors,
int *coloring,
int *reordering,
const cusparseColorInfo_t info);
/* --- Sparse Format Conversion --- */
/* 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. */
cusparseStatus_t CUSPARSEAPI cusparseSnnz(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *A,
int lda,
int *nnzPerRowCol,
int *nnzTotalDevHostPtr);
cusparseStatus_t CUSPARSEAPI cusparseDnnz(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *A,
int lda,
int *nnzPerRowCol,
int *nnzTotalDevHostPtr);
cusparseStatus_t CUSPARSEAPI cusparseCnnz(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *A,
int lda,
int *nnzPerRowCol,
int *nnzTotalDevHostPtr);
cusparseStatus_t CUSPARSEAPI cusparseZnnz(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *A,
int lda,
int *nnzPerRowCol,
int *nnzTotalDevHostPtr);
/* --- Sparse Format Conversion --- */
/* Description: This routine finds the total number of non-zero elements and
the number of non-zero elements per row in a noncompressed csr matrix A. */
cusparseStatus_t CUSPARSEAPI cusparseSnnz_compress(cusparseHandle_t handle,
int m,
const cusparseMatDescr_t descr,
const float *values,
const int *rowPtr,
int *nnzPerRow,
int *nnzTotal,
float tol);
cusparseStatus_t CUSPARSEAPI cusparseDnnz_compress(cusparseHandle_t handle,
int m,
const cusparseMatDescr_t descr,
const double *values,
const int *rowPtr,
int *nnzPerRow,
int *nnzTotal,
double tol);
cusparseStatus_t CUSPARSEAPI cusparseCnnz_compress(cusparseHandle_t handle,
int m,
const cusparseMatDescr_t descr,
const cuComplex *values,
const int *rowPtr,
int *nnzPerRow,
int *nnzTotal,
cuComplex tol);
cusparseStatus_t CUSPARSEAPI cusparseZnnz_compress(cusparseHandle_t handle,
int m,
const cusparseMatDescr_t descr,
const cuDoubleComplex *values,
const int *rowPtr,
int *nnzPerRow,
int *nnzTotal,
cuDoubleComplex tol);
/* Description: This routine takes as input a csr form where the values may have 0 elements
and compresses it to return a csr form with no zeros. */
cusparseStatus_t CUSPARSEAPI cusparseScsr2csr_compress(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descra,
const float *inVal,
const int *inColInd,
const int * inRowPtr,
int inNnz,
int *nnzPerRow,
float *outVal,
int *outColInd,
int *outRowPtr,
float tol);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2csr_compress(cusparseHandle_t handle,
int m, //number of rows
int n,
const cusparseMatDescr_t descra,
const double *inVal, //csr values array-the elements which are below a certain tolerance will be remvoed
const int *inColInd,
const int * inRowPtr, //corresponding input noncompressed row pointer
int inNnz,
int *nnzPerRow, //output: returns number of nonzeros per row
double *outVal,
int *outColInd,
int *outRowPtr,
double tol);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2csr_compress(cusparseHandle_t handle,
int m, //number of rows
int n,
const cusparseMatDescr_t descra,
const cuComplex *inVal, //csr values array-the elements which are below a certain tolerance will be remvoed
const int *inColInd,
const int * inRowPtr, //corresponding input noncompressed row pointer
int inNnz,
int *nnzPerRow, //output: returns number of nonzeros per row
cuComplex *outVal,
int *outColInd,
int *outRowPtr,
cuComplex tol);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2csr_compress(cusparseHandle_t handle,
int m, //number of rows
int n,
const cusparseMatDescr_t descra,
const cuDoubleComplex *inVal, //csr values array-the elements which are below a certain tolerance will be remvoed
const int *inColInd,
const int * inRowPtr, //corresponding input noncompressed row pointer
int inNnz,
int *nnzPerRow, //output: returns number of nonzeros per row
cuDoubleComplex *outVal,
int *outColInd,
int *outRowPtr,
cuDoubleComplex tol);
/* Description: This routine converts a dense matrix to a sparse matrix
in the CSR storage format, using the information computed by the
nnz routine. */
cusparseStatus_t CUSPARSEAPI cusparseSdense2csr(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *A,
int lda,
const int *nnzPerRow,
float *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
cusparseStatus_t CUSPARSEAPI cusparseDdense2csr(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *A,
int lda,
const int *nnzPerRow,
double *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
cusparseStatus_t CUSPARSEAPI cusparseCdense2csr(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *A,
int lda,
const int *nnzPerRow,
cuComplex *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
cusparseStatus_t CUSPARSEAPI cusparseZdense2csr(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *A,
int lda,
const int *nnzPerRow,
cuDoubleComplex *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
/* Description: This routine converts a sparse matrix in CSR storage format
to a dense matrix. */
cusparseStatus_t CUSPARSEAPI cusparseScsr2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
float *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
double *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cuComplex *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cuDoubleComplex *A,
int lda);
/* Description: This routine converts a dense matrix to a sparse matrix
in the CSC storage format, using the information computed by the
nnz routine. */
cusparseStatus_t CUSPARSEAPI cusparseSdense2csc(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *A,
int lda,
const int *nnzPerCol,
float *cscSortedValA,
int *cscSortedRowIndA,
int *cscSortedColPtrA);
cusparseStatus_t CUSPARSEAPI cusparseDdense2csc(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *A,
int lda,
const int *nnzPerCol,
double *cscSortedValA,
int *cscSortedRowIndA,
int *cscSortedColPtrA);
cusparseStatus_t CUSPARSEAPI cusparseCdense2csc(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *A,
int lda,
const int *nnzPerCol,
cuComplex *cscSortedValA,
int *cscSortedRowIndA,
int *cscSortedColPtrA);
cusparseStatus_t CUSPARSEAPI cusparseZdense2csc(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *A,
int lda,
const int *nnzPerCol,
cuDoubleComplex *cscSortedValA,
int *cscSortedRowIndA,
int *cscSortedColPtrA);
/* Description: This routine converts a sparse matrix in CSC storage format
to a dense matrix. */
cusparseStatus_t CUSPARSEAPI cusparseScsc2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
float *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseDcsc2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
double *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseCcsc2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
cuComplex *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseZcsc2dense(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
cuDoubleComplex *A,
int lda);
/* Description: This routine compresses the indecis of rows or columns.
It can be interpreted as a conversion from COO to CSR sparse storage
format. */
cusparseStatus_t CUSPARSEAPI cusparseXcoo2csr(cusparseHandle_t handle,
const int *cooRowInd,
int nnz,
int m,
int *csrSortedRowPtr,
cusparseIndexBase_t 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. */
cusparseStatus_t CUSPARSEAPI cusparseXcsr2coo(cusparseHandle_t handle,
const int *csrSortedRowPtr,
int nnz,
int m,
int *cooRowInd,
cusparseIndexBase_t 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. */
cusparseStatus_t CUSPARSEAPI cusparseCsr2cscEx(cusparseHandle_t handle,
int m,
int n,
int nnz,
const void *csrSortedVal,
cudaDataType csrSortedValtype,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
void *cscSortedVal,
cudaDataType cscSortedValtype,
int *cscSortedRowInd,
int *cscSortedColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t idxBase,
cudaDataType executiontype);
cusparseStatus_t CUSPARSEAPI cusparseScsr2csc(cusparseHandle_t handle,
int m,
int n,
int nnz,
const float *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
float *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2csc(cusparseHandle_t handle,
int m,
int n,
int nnz,
const double *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
double *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2csc(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cuComplex *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
cuComplex *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t idxBase);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2csc(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cuDoubleComplex *csrSortedVal,
const int *csrSortedRowPtr,
const int *csrSortedColInd,
cuDoubleComplex *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t idxBase);
/* Description: This routine converts a dense matrix to a sparse matrix
in HYB storage format. */
cusparseStatus_t CUSPARSEAPI cusparseSdense2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *A,
int lda,
const int *nnzPerRow,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseDdense2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *A,
int lda,
const int *nnzPerRow,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseCdense2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *A,
int lda,
const int *nnzPerRow,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseZdense2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *A,
int lda,
const int *nnzPerRow,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
/* Description: This routine converts a sparse matrix in HYB storage format
to a dense matrix. */
cusparseStatus_t CUSPARSEAPI cusparseShyb2dense(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
float *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseDhyb2dense(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
double *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseChyb2dense(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
cuComplex *A,
int lda);
cusparseStatus_t CUSPARSEAPI cusparseZhyb2dense(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
cuDoubleComplex *A,
int lda);
/* Description: This routine converts a sparse matrix in CSR storage format
to a sparse matrix in HYB storage format. */
cusparseStatus_t CUSPARSEAPI cusparseScsr2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
/* Description: This routine converts a sparse matrix in HYB storage format
to a sparse matrix in CSR storage format. */
cusparseStatus_t CUSPARSEAPI cusparseShyb2csr(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
float *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
cusparseStatus_t CUSPARSEAPI cusparseDhyb2csr(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
double *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
cusparseStatus_t CUSPARSEAPI cusparseChyb2csr(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
cuComplex *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
cusparseStatus_t CUSPARSEAPI cusparseZhyb2csr(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
cuDoubleComplex *csrSortedValA,
int *csrSortedRowPtrA,
int *csrSortedColIndA);
/* Description: This routine converts a sparse matrix in CSC storage format
to a sparse matrix in HYB storage format. */
cusparseStatus_t CUSPARSEAPI cusparseScsc2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseDcsc2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseCcsc2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
cusparseStatus_t CUSPARSEAPI cusparseZcsc2hyb(cusparseHandle_t handle,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *cscSortedValA,
const int *cscSortedRowIndA,
const int *cscSortedColPtrA,
cusparseHybMat_t hybA,
int userEllWidth,
cusparseHybPartition_t partitionType);
/* Description: This routine converts a sparse matrix in HYB storage format
to a sparse matrix in CSC storage format. */
cusparseStatus_t CUSPARSEAPI cusparseShyb2csc(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
float *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr);
cusparseStatus_t CUSPARSEAPI cusparseDhyb2csc(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
double *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr);
cusparseStatus_t CUSPARSEAPI cusparseChyb2csc(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
cuComplex *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr);
cusparseStatus_t CUSPARSEAPI cusparseZhyb2csc(cusparseHandle_t handle,
const cusparseMatDescr_t descrA,
const cusparseHybMat_t hybA,
cuDoubleComplex *cscSortedVal,
int *cscSortedRowInd,
int *cscSortedColPtr);
/* Description: This routine converts a sparse matrix in CSR storage format
to a sparse matrix in block-CSR storage format. */
cusparseStatus_t CUSPARSEAPI cusparseXcsr2bsrNnz(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
int *bsrSortedRowPtrC,
int *nnzTotalDevHostPtr);
cusparseStatus_t CUSPARSEAPI cusparseScsr2bsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
float *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2bsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
double *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2bsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
cuComplex *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2bsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
cuDoubleComplex *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC);
/* Description: This routine converts a sparse matrix in block-CSR storage format
to a sparse matrix in CSR storage format. */
cusparseStatus_t CUSPARSEAPI cusparseSbsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
float *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseDbsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
double *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseCbsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
cuComplex *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
cusparseStatus_t CUSPARSEAPI cusparseZbsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int blockDim,
const cusparseMatDescr_t descrC,
cuDoubleComplex *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC);
/* Description: This routine converts a sparse matrix in general block-CSR storage format
to a sparse matrix in general block-CSC storage format. */
cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSize(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSize(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSize(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSize(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc_bufferSizeExt(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc_bufferSizeExt(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc_bufferSizeExt(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc_bufferSizeExt(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsc(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const float *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
float *bscVal,
int *bscRowInd,
int *bscColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t baseIdx,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsc(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const double *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
double *bscVal,
int *bscRowInd,
int *bscColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t baseIdx,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsc(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const cuComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
cuComplex *bscVal,
int *bscRowInd,
int *bscColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t baseIdx,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsc(cusparseHandle_t handle,
int mb,
int nb,
int nnzb,
const cuDoubleComplex *bsrSortedVal,
const int *bsrSortedRowPtr,
const int *bsrSortedColInd,
int rowBlockDim,
int colBlockDim,
cuDoubleComplex *bscVal,
int *bscRowInd,
int *bscColPtr,
cusparseAction_t copyValues,
cusparseIndexBase_t baseIdx,
void *pBuffer);
/* Description: This routine converts a sparse matrix in general block-CSR storage format
to a sparse matrix in CSR storage format. */
cusparseStatus_t CUSPARSEAPI cusparseXgebsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
const cusparseMatDescr_t descrC,
int *csrSortedRowPtrC,
int *csrSortedColIndC );
cusparseStatus_t CUSPARSEAPI cusparseSgebsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
const cusparseMatDescr_t descrC,
float *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC );
cusparseStatus_t CUSPARSEAPI cusparseDgebsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
const cusparseMatDescr_t descrC,
double *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC );
cusparseStatus_t CUSPARSEAPI cusparseCgebsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
const cusparseMatDescr_t descrC,
cuComplex *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC );
cusparseStatus_t CUSPARSEAPI cusparseZgebsr2csr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDim,
int colBlockDim,
const cusparseMatDescr_t descrC,
cuDoubleComplex *csrSortedValC,
int *csrSortedRowPtrC,
int *csrSortedColIndC );
/* Description: This routine converts a sparse matrix in CSR storage format
to a sparse matrix in general block-CSR storage format. */
cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
int *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
int rowBlockDim,
int colBlockDim,
size_t *pBufferSize);
cusparseStatus_t CUSPARSEAPI cusparseXcsr2gebsrNnz(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrC,
int *bsrSortedRowPtrC,
int rowBlockDim,
int colBlockDim,
int *nnzTotalDevHostPtr,
void *pBuffer );
cusparseStatus_t CUSPARSEAPI cusparseScsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const float *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrC,
float *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const double *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrC,
double *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrC,
cuComplex *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int m,
int n,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *csrSortedValA,
const int *csrSortedRowPtrA,
const int *csrSortedColIndA,
const cusparseMatDescr_t descrC,
cuDoubleComplex *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDim,
int colBlockDim,
void *pBuffer);
/* Description: This routine converts a sparse matrix in general block-CSR storage format
to a sparse matrix in general block-CSR storage format with different block size. */
cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
int *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
int *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
int *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSize(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
int *pBufferSizeInBytes );
cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
size_t *pBufferSize );
cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
size_t *pBufferSize );
cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
size_t *pBufferSize );
cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr_bufferSizeExt(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
int rowBlockDimC,
int colBlockDimC,
size_t *pBufferSize );
cusparseStatus_t CUSPARSEAPI cusparseXgebsr2gebsrNnz(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
const cusparseMatDescr_t descrC,
int *bsrSortedRowPtrC,
int rowBlockDimC,
int colBlockDimC,
int *nnzTotalDevHostPtr,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseSgebsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const float *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
const cusparseMatDescr_t descrC,
float *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDgebsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const double *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
const cusparseMatDescr_t descrC,
double *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCgebsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
const cusparseMatDescr_t descrC,
cuComplex *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZgebsr2gebsr(cusparseHandle_t handle,
cusparseDirection_t dirA,
int mb,
int nb,
int nnzb,
const cusparseMatDescr_t descrA,
const cuDoubleComplex *bsrSortedValA,
const int *bsrSortedRowPtrA,
const int *bsrSortedColIndA,
int rowBlockDimA,
int colBlockDimA,
const cusparseMatDescr_t descrC,
cuDoubleComplex *bsrSortedValC,
int *bsrSortedRowPtrC,
int *bsrSortedColIndC,
int rowBlockDimC,
int colBlockDimC,
void *pBuffer);
/* --- Sparse Matrix Sorting --- */
/* Description: Create a identity sequence p=[0,1,...,n-1]. */
cusparseStatus_t CUSPARSEAPI cusparseCreateIdentityPermutation(cusparseHandle_t handle,
int n,
int *p);
/* Description: Sort sparse matrix stored in COO format */
cusparseStatus_t CUSPARSEAPI cusparseXcoosort_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int nnz,
const int *cooRowsA,
const int *cooColsA,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseXcoosortByRow(cusparseHandle_t handle,
int m,
int n,
int nnz,
int *cooRowsA,
int *cooColsA,
int *P,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseXcoosortByColumn(cusparseHandle_t handle,
int m,
int n,
int nnz,
int *cooRowsA,
int *cooColsA,
int *P,
void *pBuffer);
/* Description: Sort sparse matrix stored in CSR format */
cusparseStatus_t CUSPARSEAPI cusparseXcsrsort_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int nnz,
const int *csrRowPtrA,
const int *csrColIndA,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseXcsrsort(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
const int *csrRowPtrA,
int *csrColIndA,
int *P,
void *pBuffer);
/* Description: Sort sparse matrix stored in CSC format */
cusparseStatus_t CUSPARSEAPI cusparseXcscsort_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int nnz,
const int *cscColPtrA,
const int *cscRowIndA,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseXcscsort(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
const int *cscColPtrA,
int *cscRowIndA,
int *P,
void *pBuffer);
/* Description: Wrapper that sorts sparse matrix stored in CSR format
(without exposing the permutation). */
cusparseStatus_t CUSPARSEAPI cusparseScsru2csr_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int nnz,
float *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int nnz,
double *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int nnz,
cuComplex *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr_bufferSizeExt(cusparseHandle_t handle,
int m,
int n,
int nnz,
cuDoubleComplex *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseScsru2csr(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
float *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsru2csr(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
double *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsru2csr(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsru2csr(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
/* Description: Wrapper that un-sorts sparse matrix stored in CSR format
(without exposing the permutation). */
cusparseStatus_t CUSPARSEAPI cusparseScsr2csru(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
float *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDcsr2csru(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
double *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseCcsr2csru(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
cuComplex *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseZcsr2csru(cusparseHandle_t handle,
int m,
int n,
int nnz,
const cusparseMatDescr_t descrA,
cuDoubleComplex *csrVal,
const int *csrRowPtr,
int *csrColInd,
csru2csrInfo_t info,
void *pBuffer);
/* Description: prune dense matrix to a sparse matrix with CSR format */
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csr_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const __half *A,
int lda,
const __half *threshold,
const cusparseMatDescr_t descrC,
const __half *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
size_t *pBufferSizeInBytes);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const float *A,
int lda,
const float *threshold,
const cusparseMatDescr_t descrC,
const float *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const double *A,
int lda,
const double *threshold,
const cusparseMatDescr_t descrC,
const double *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
size_t *pBufferSizeInBytes);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrNnz(
cusparseHandle_t handle,
int m,
int n,
const __half *A,
int lda,
const __half *threshold,
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr,
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnz(
cusparseHandle_t handle,
int m,
int n,
const float *A,
int lda,
const float *threshold,
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnz(
cusparseHandle_t handle,
int m,
int n,
const double *A,
int lda,
const double *threshold,
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr,
void *pBuffer);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csr(
cusparseHandle_t handle,
int m,
int n,
const __half *A,
int lda,
const __half *threshold,
const cusparseMatDescr_t descrC,
__half *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csr(
cusparseHandle_t handle,
int m,
int n,
const float *A,
int lda,
const float *threshold,
const cusparseMatDescr_t descrC,
float *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csr(
cusparseHandle_t handle,
int m,
int n,
const double *A,
int lda,
const double *threshold,
const cusparseMatDescr_t descrC,
double *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
void *pBuffer);
/* Description: prune sparse matrix with CSR format to another sparse matrix with CSR format */
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csr_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const __half *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const __half *threshold,
const cusparseMatDescr_t descrC,
const __half *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
size_t *pBufferSizeInBytes);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const float *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const float *threshold,
const cusparseMatDescr_t descrC,
const float *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const double *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const double *threshold,
const cusparseMatDescr_t descrC,
const double *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
size_t *pBufferSizeInBytes);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrNnz(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const __half *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const __half *threshold,
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnz(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const float *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const float *threshold,
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnz(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const double *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const double *threshold,
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
void *pBuffer);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csr(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const __half *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const __half *threshold,
const cusparseMatDescr_t descrC,
__half *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csr(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const float *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const float *threshold,
const cusparseMatDescr_t descrC,
float *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csr(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const double *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
const double *threshold,
const cusparseMatDescr_t descrC,
double *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
void *pBuffer);
/* Description: prune dense matrix to a sparse matrix with CSR format by percentage */
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrByPercentage_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const __half *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
const __half *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
pruneInfo_t info,
size_t *pBufferSizeInBytes);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const float *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
const float *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
pruneInfo_t info,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
const double *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
const double *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
pruneInfo_t info,
size_t *pBufferSizeInBytes);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrNnzByPercentage(
cusparseHandle_t handle,
int m,
int n,
const __half *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
pruneInfo_t info,
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrNnzByPercentage(
cusparseHandle_t handle,
int m,
int n,
const float *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
pruneInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrNnzByPercentage(
cusparseHandle_t handle,
int m,
int n,
const double *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
pruneInfo_t info,
void *pBuffer);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrByPercentage(
cusparseHandle_t handle,
int m,
int n,
const __half *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
__half *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
pruneInfo_t info,
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneDense2csrByPercentage(
cusparseHandle_t handle,
int m,
int n,
const float *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
float *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
pruneInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneDense2csrByPercentage(
cusparseHandle_t handle,
int m,
int n,
const double *A,
int lda,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
double *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
pruneInfo_t info,
void *pBuffer);
/* Description: prune sparse matrix to a sparse matrix with CSR format by percentage*/
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrByPercentage_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const __half *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
const __half *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
pruneInfo_t info,
size_t *pBufferSizeInBytes);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const float *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
const float *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
pruneInfo_t info,
size_t *pBufferSizeInBytes);
cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage_bufferSizeExt(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const double *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
const double *csrValC,
const int *csrRowPtrC,
const int *csrColIndC,
pruneInfo_t info,
size_t *pBufferSizeInBytes);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrNnzByPercentage(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const __half *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
pruneInfo_t info,
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrNnzByPercentage(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const float *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
pruneInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrNnzByPercentage(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const double *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
int *csrRowPtrC,
int *nnzTotalDevHostPtr, /* can be on host or device */
pruneInfo_t info,
void *pBuffer);
#if defined(__cplusplus)
cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrByPercentage(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const __half *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
__half *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
pruneInfo_t info,
void *pBuffer);
#endif
cusparseStatus_t CUSPARSEAPI cusparseSpruneCsr2csrByPercentage(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const float *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
float *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
pruneInfo_t info,
void *pBuffer);
cusparseStatus_t CUSPARSEAPI cusparseDpruneCsr2csrByPercentage(
cusparseHandle_t handle,
int m,
int n,
int nnzA,
const cusparseMatDescr_t descrA,
const double *csrValA,
const int *csrRowPtrA,
const int *csrColIndA,
float percentage, /* between 0 to 100 */
const cusparseMatDescr_t descrC,
double *csrValC,
const int *csrRowPtrC,
int *csrColIndC,
pruneInfo_t info,
void *pBuffer);
#if defined(__cplusplus)
}
#endif /* __cplusplus */
#endif /* !defined(CUSPARSE_H_) */
Reference in New Issue View Git Blame Copy Permalink