cuSPARSE

为稀疏矩阵提供基本的线性代数运算。有关cuSPARSE 库及其方法和数据类型的深入描述，请参阅NVIDIA cuSPARSE。所有函数都通过accelerate.cuda.sparse.Sparse类访问：

类accelerate.cuda.sparse.Sparse( *args , **kws )

所有 cuSPARSE 函数都可以在 Sparse 对象下使用。

参数：idxbase – 索引的基数，0 或 1。可选，默认为 0。

与 cuBLAS 接口类似，函数对不同数据类型的操作没有使用特殊的命名约定——所有数据类型由每个函数处理，相应库函数的调度由 Accelerate 处理。但是，通常需要为函数提供矩阵描述符，它提供有关矩阵格式和属性的一些信息。可以从该accelerate.cuda.sparse.Sparse.matdescr()方法获得矩阵描述符 ：

accelerate.cuda.sparse.Sparse.matdescr（indexbase，diagtype，FILLMODE，基质型）

创建一个矩阵描述符，该描述符描述具有给定 indexbase、diagtype、fillmode和matrixtype 的矩阵。请注意，并非所有这些选项都与每种矩阵存储格式相关。

参数：
  • 索引库- 可选。0 表示基于 0 的索引，或 1 表示基于 1 的索引。如果未指定，accelerate.cuda.sparse.Sparse则使用为构造函数提供的默认值 。
  • diagtype - 可选。默认为'N'。'N'表示矩阵对角线具有非单位元素。'U'表示矩阵对角线仅包含单位元素。
  • 填充模式- 可选。默认为'L'。'L'表示存储矩阵的下三角部分。'U'表示存储矩阵的上三角部分。
  • 矩阵类型- 可选。默认为'G'。'S'表示矩阵是对称的。'H'表示矩阵是 Hermitian。'T'表示矩阵是三角形的。 'G'用于一般矩阵，它不是对称、厄米或三角形的。
返回：

矩阵描述符。

accelerate.cuda.sparse.Sparse该类的许多方法都接受构成矩阵稀疏表示的单个数据结构（例如，CSR 格式矩阵的值、行指针和列索引）。但是，某些方法（例如 accelerate.cuda.sparse.Sparse.csrgemm_ez()）接受accelerate.cuda.sparse.CudaSparseMatrix类的实例 ：

类accelerate.cuda.sparse.CudaSparseMatrix

用于在 CUDA 设备上表示稀疏矩阵的基类。构造函数不接受任何参数。

from_host_matrix(矩阵,流)

从主机上的矩阵实例初始化矩阵结构和值。宿主矩阵必须是相应的宿主类型，下面针对每个子类进行了记录。

copy_to_host(流)

创建相应主机矩阵类型的实例，并将矩阵结构和数据从设备复制到其中。有关相应矩阵类型的指示，请参阅子类文档。

稀疏矩阵类型的子类是：

类accelerate.cuda.sparse.CudaBSRMatrix

对应类型为 a 的 CUDA 稀疏矩阵 scipy.sparse.bsr_matrix。

类accelerate.cuda.sparse.CudaCSRMatrix

对应类型为 a 的 CUDA 稀疏矩阵 scipy.sparse.csr_matrix。

类accelerate.cuda.sparse.CudaCSCMatrix

对应类型为 a 的 CUDA 稀疏矩阵 scipy.sparse.csc_matrix。

还有一些方便的方法可以以类似于 Scipy 稀疏矩阵的方式构造 CUDA 稀疏矩阵：

sparse.bsr_matrix( *args , **kws )

采用与 相同的参数scipy.sparse.bsr_matrix。

返回一个 BSR CUDA 矩阵。

sparse.csr_matrix( *args , **kws )

采用与 相同的参数scipy.sparse.csr_matrix。

返回 CSR CUDA 矩阵。

sparse.csc_matrix( *args , **kws )

采用与 相同的参数scipy.sparse.csc_matrix。

返回一个 CSC CUDA 矩阵。

BLAS 级别 1

accelerate.cuda.sparse.Sparse.axpyi( alpha , xVal , xInd , y )

将稀疏向量x乘以alpha并将结果添加到密集向量y。

参数：
  • alpha – 标量
  • xVal – x的非零值向量
  • xInd – x的非零值的索引向量
  • y – 密集向量
返回：

密集向量
accelerate.cuda.sparse.Sparse.doti( xVal , xInd , y )

计算稀疏向量x和密集向量y的点积。

参数：
  • xVal – x的非零值向量
  • xInd – x的非零值的索引向量
  • y – 密集向量
返回：

标量
accelerate.cuda.sparse.Sparse.dotci( xVal , xInd , y )

计算稀疏向量x 和密集向量y的复共轭的点积。

参数：
  • xVal – x的非零值向量
  • xInd – x的非零值的索引向量
  • y – 密集向量
返回：

标量
accelerate.cuda.sparse.Sparse.gthr( y , xVal , xInd )

将索引xInd处的y元素收集到数组xVal 中

参数：
  • xVal – x的非零值向量
  • xInd – x的非零值的索引向量
  • y – 密集向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.gthrz( y , xVal , xInd )

将索引xInd处的y元素收集到数组xVal 中，并将y收集的元素归零。

参数：
  • xVal – x的非零值向量
  • xInd – x的非零值的索引向量
  • y – 密集向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.roti( xVal , xInd , y , c , s )

应用 Givens 旋转矩阵G：

\[\begin{split}G = \left( \begin{array}{cc} C & S \\ -S & C \end{array}\right)\end{split}\]

到稀疏向量x和密集向量 y。

参数：
  • xVal – x的非零值向量
  • xInd – x的非零值的索引向量
  • y – 密集向量
  • c – 旋转矩阵的余弦元素
  • s – 旋转矩阵的正弦元素
返回：

没有任何
accelerate.cuda.sparse.Sparse.sctr( xVal , xInd , y )

将稀疏向量x的元素分散到密集向量y 中。未在xInd中列出索引的y元素未修改。

参数：
  • xVal – x的非零值向量
  • xInd – x的非零值的索引向量
  • y – 密集向量
返回：

没有任何

BLAS 级别 2

对于以下参数，所有 2 级例程都遵循以下命名约定：

  • alpha, beta –（标量）可以是实数或复数。

  • descr, descrA, descrB –（描述符）矩阵描述符。可以通过调用 获得适当的描述符 accelerate.cuda.sparse.Sparse.matdescr()。descr仅适用于唯一的矩阵参数。descrA和descrB 分别适用于矩阵A和矩阵 B。

  • dir –（字符串）可以是'C'表示列主要块存储或'R' 表示行主要块存储。

  • trans, transa, transb –（字符串）

    选择要应用于矩阵的操作op：

    • 'N' : op(X) = X，恒等运算；
    • 'T' : op(X) = X**T，转置；
    • 'C' : op(X) = X**H，共轭转置。

    trans仅适用于唯一的矩阵参数。 transa和transb 分别适用于矩阵A和矩阵B。

accelerate.cuda.sparse.Sparse.bsrmv_matrix( dir , trans , alpha , descr , bsrmat , x , beta , y )

矩阵向量乘法y = alpha * op(A) * x + beta * y与 BSR 格式矩阵。

参数：
  • dir – 块存储方向
  • trans – 应用于矩阵的操作
  • alpha – 标量
  • descr – 矩阵描述符
  • bsrmat – 矩阵A
  • x – 密集向量
  • beta – 标量
  • y – 密集向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.bsrmv( dir , trans , mb , nb , nnzb , alpha , descr , bsrVal , bsrRowPtr , bsrColInd , blockDim , x , beta , y )

矩阵向量乘法y = alpha * op(A) * x + beta * y与 BSR 格式矩阵。此函数接受构成 BSR 矩阵结构的单个数组 - 如果要处理 accelerate.cuda.sparse.CudaBSRMatrix实例，建议改用该bsrmv_matrix()方法。

参数：
  • dir – 块存储方向
  • trans – 应用于矩阵的操作
  • mb – 矩阵的块行数
  • nb – 矩阵的块列数
  • nnzb – 矩阵的非零块数
  • alpha – 标量
  • descr – 矩阵描述符
  • bsrVal – 矩阵的非零值向量
  • bsrRowPtr – 矩阵块行指针的向量
  • bsrColInd – 矩阵块列索引的向量
  • blockDim – 矩阵的块维度
  • x – 密集向量
  • beta – 标量
  • y – 密集向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.bsrxmv( dir , trans , sizeOfMask , mb , nb , nnzb , alpha , descr , bsrVal , bsrMaskPtr , bsrRowPtr , bsrEndPtr , bsrColInd , blockDim , x , beta , y )

矩阵向量乘法类似于bsrmv()，但包括掩码操作：y(mask) = (alpha * op(A) * x + beta * y)(mask)。要更新的 y 块在bsrMaskPtr中指定。未在bsrMaskPtr中指定索引的块保持不变。

参数：
  • dir – 块存储方向
  • trans – 应用于矩阵的操作
  • sizeOfMask – y行的更新块数
  • mb – 矩阵的块行数
  • nb – 矩阵的块列数
  • nnzb – 矩阵的非零块数
  • alpha – 标量
  • descr – 矩阵描述符
  • bsrVal – 矩阵的非零值向量
  • bsrMaskPtr – 要更新的块元素的索引向量
  • bsrRowPtr – 矩阵块行指针的向量
  • bsrEndPtr – 指向每个块行末尾的指针向量加一
  • bsrColInd – 矩阵块列索引的向量
  • blockDim – 矩阵的块维度
  • x – 密集向量
  • beta – 标量
  • y – 密集向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.csrmv( trans , m , n , nnz , alpha , descr , csrVal , csrRowPtr , csrColInd , x , beta , y )

矩阵向量乘法y = alpha * op(A) * x + beta * y与 CSR 格式矩阵。

参数：
  • trans – 应用于矩阵的操作
  • m – 矩阵的行数
  • n – 矩阵的列数
  • nnz – 矩阵的非零数
  • alpha – 标量
  • descr – 矩阵描述符
  • csrVal – 矩阵的非零值向量
  • csrRowPtr – 矩阵的行指针向量
  • csrColInd – 矩阵的列索引向量
  • x – 密集向量
  • beta – 标量
  • y – 密集向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.csrsv_analysis( trans , m , nnz , descr , csrVal , csrRowPtr , csrColInd )

执行稀疏三角形线性系统op(A) * y = alpha * x的解的分析阶段。对于给定的矩阵和操作类型，只需执行一次。

参数：
  • trans – 应用于矩阵的操作
  • m – 矩阵的行数
  • nnz – 矩阵的非零数
  • descr – 矩阵描述符
  • csrVal – 矩阵的非零值向量
  • csrRowPtr – 矩阵的行指针向量
  • csrColInd – 矩阵的列索引向量
返回：

分析结果，可用作求解阶段的输入
accelerate.cuda.sparse.Sparse.csrsv_solve( trans , m , alpha , descr , csrVal , csrRowPtr , csrColInd , info , x , y )

执行稀疏三角形线性系统op(A) * y = alpha * x的解的分析阶段。

参数：
  • trans – 应用于矩阵的操作
  • m – 矩阵的行数
  • alpha – 标量
  • descr – 矩阵描述符
  • csrVal – 矩阵的非零值向量
  • csrRowPtr – 矩阵的行指针向量
  • csrColInd – 矩阵的列索引向量
  • info – 分析结果来自csrsv_analysis()
  • x – 密集向量
  • y - 存储求解结果的密集向量
返回：

没有任何

BLAS 级别 3

accelerate.cuda.sparse.Sparse.csrmm( transA , m , n , k , nnz , alpha , descrA , csrValA , csrRowPtrA , csrColIndA , B , ldb , beta , C , ldc )

矩阵-矩阵乘法C = alpha * op(A) * B + beta * C其中A是 CSR 格式的稀疏矩阵，B和C是密集矩阵。

参数：
  • transA – 应用于A 的操作
  • m – A的行数
  • n – B和C的列数
  • k – A的列数
  • nnz – A中非零的数量
  • alpha – 标量
  • descrA – 矩阵描述符
  • csrValA – A的非零值向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • B – 密集矩阵
  • ldb – B 的领先维度
  • beta – 标量
  • C – 密集矩阵
  • ldc – C 的主要维度
返回：

没有任何
accelerate.cuda.sparse.Sparse.csrmm2( transA , transB , m , n , k , nnz , alpha , descrA , csrValA , csrRowPtrA , csrColIndA , B , ldb , beta , C , ldc )

矩阵-矩阵乘法C = alpha * op(A) * op(B) + beta * C其中A是 CSR 格式的稀疏矩阵，B和C是密集矩阵。

参数：
  • transA – 应用于A 的操作
  • transB – 应用于B 的操作
  • m – A的行数
  • n – B和C的列数
  • k – A的列数
  • nnz – A中非零的数量
  • alpha – 标量
  • descrA – 矩阵描述符
  • csrValA – A的非零值向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • B – 密集矩阵
  • ldb – B 的领先维度
  • beta – 标量
  • C – 密集矩阵
  • ldc – C 的主要维度
返回：

没有任何
accelerate.cuda.sparse.Sparse.csrsm_analysis( transA , m , nnz , descrA , csrValA , csrRowPtrA , csrColIndA )

执行具有多个右侧的稀疏三角形线性系统op(A) * Y = alpha * X的解的分析阶段，其中A是 CSR 格式的稀疏矩阵，X和Y是密集矩阵。

参数：
  • transA – 应用于A 的操作
  • m – A的行数
  • nnz – A中非零的数量
  • descrA – 矩阵描述符
  • csrValA – A的非零值向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
返回：

分析结果
accelerate.cuda.sparse.Sparse.csrsm_solve( transA , m , n , alpha , descrA , csrValA , csrRowPtrA , csrColIndA , info , X , ldx , Y , ldy )

执行具有多个右侧的稀疏三角形线性系统op(A) * Y = alpha * X的解的分析阶段，其中A是 CSR 格式的稀疏矩阵，X和Y是密集矩阵。

参数：
  • transA – 应用于A 的操作
  • m – A的行数
  • n – B和C的列数
  • alpha – 标量
  • descrA – 矩阵描述符
  • csrValA – A的非零值向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • info – 分析结果来自csrsm_analysis()
  • X - 密集矩阵
  • ldx – X 的前导维度
  • Y - 密集矩阵
  • ldy – Y 的领先维度
返回：

没有任何

额外功能

accelerate.cuda.sparse.Sparse.XcsrgeamNnz( m , n , descrA , nnzA , csrRowPtrA , csrColIndA , descrB , nnzB , csrRowPtrB , csrColIndB , descrC , csrRowPtrC )

为矩阵运算设置稀疏模式C = alpha * A + beta * B其中A、B和C都是 CSR 格式的稀疏矩阵。

参数：
  • m – 所有矩阵的行数
  • n – 所有矩阵的列数
  • descrA – A 的矩阵描述符
  • nnzA – A 中的非零数
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • descrB – B 的矩阵描述符
  • nnzB – B 中的非零数
  • csrRowPtrB – B的行指针向量
  • csrColIndB – B的列索引向量
  • descrC – B 的矩阵描述符
  • csrRowPtrC – C的行指针向量，由此方法写入
返回：

C 中的非零数
accelerate.cuda.sparse.Sparse.csrgeam（米，Ñ，阿尔法，descrA，nnzA，csrValA，csrRowPtrA，csrColIndA，测试，descrB，nnzB，csrValB，csrRowPtrB，csrColIndB，descrC，csrValC，csrRowPtrC，csrColIndC ）

执行矩阵运算C = alpha * A + beta * B其中A、B和C都是 CSR 格式的稀疏矩阵。

参数：
  • m – 所有矩阵的行数
  • n – 所有矩阵的列数
  • alpha – 标量
  • descrA – A 的矩阵描述符
  • nnzA – A 中的非零数
  • csrValA – A的非零值向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • beta – 标量
  • descrB – B 的矩阵描述符
  • nnzB – B 中的非零数
  • csrValB – B的非零值向量
  • csrRowPtrB – B的行指针向量
  • csrColIndB – B的列索引向量
  • descrC – B 的矩阵描述符
  • csrValC – C的非零值向量
  • csrRowPtrC – C的行指针向量
  • csrColIndC – C的列索引向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.XcsrgemmNnz( transA , transB , m , n , k , descrA , nnzA , csrRowPtrA , csrColIndA , descrB , nnzB , csrRowPtrB , csrColIndB , descrC , csrRowPtrC )

为矩阵运算C = op(A) * op(B)设置稀疏模式， 其中A、B和C都是 CSR 格式的稀疏矩阵。

参数：
  • transA – 应用于A 的操作
  • transB – 应用于B 的操作
  • m – A和C的行数
  • n – B和C的列数
  • k – A / B的列/行数
  • descrA – A 的矩阵描述符
  • nnzA – A 中的非零数
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • descrB – B 的矩阵描述符
  • nnzB – B 中的非零数
  • csrRowPtrB – B的行指针向量
  • csrColIndB – B的列索引向量
  • descrC – C 的矩阵描述符
  • csrRowPtrC – C的行指针向量，由该函数编写
返回：

C 中的非零数
accelerate.cuda.sparse.Sparse.csrgemm（transA，transB，米，Ñ，ķ，descrA，nnzA，csrValA，csrRowPtrA，csrColIndA，descrB，nnzB，csrValB，csrRowPtrB，csrColIndB，descrC，csrValC，csrRowPtrC，csrColIndC ）

执行矩阵运算C = op(A) * op(B)其中A、B和C都是 CSR 格式的稀疏矩阵。

参数：
  • transA – 应用于A 的操作
  • transB – 应用于B 的操作
  • m – A和C的行数
  • n – B和C的列数
  • k – A / B的列/行数
  • descrA – A 的矩阵描述符
  • nnzA – A 中的非零数
  • csrValA – A中非零值的向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • descrB – B 的矩阵描述符
  • nnzB – B 中的非零数
  • csrValB – B中非零值的向量
  • csrRowPtrB – B的行指针向量
  • csrColIndB – B的列索引向量
  • descrC – C 的矩阵描述符
  • csrValC – C中非零值的向量
  • csrRowPtrC – C的行指针向量
  • csrColIndC – C的列索引向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.csrgemm_ez( A , B , transA='N' , transB='N' , descrA=None , descrB=None , descrC=None )
执行矩阵运算C = op(A) * op(B)其中A、B和C 都是 CSR 格式的稀疏矩阵。此函数接受并返回 accelerate.cuda.sparse.CudaCSRMatrix矩阵，并调用XcsrgemmNnz()和csrgemm()。
参数：
返回：

accelerate.cuda.sparse.CudaCSRMatrix

预处理器 ¶

accelerate.cuda.sparse.Sparse.csric0( trans , m , descr , csrValA , csrRowPtrA , csrColIndA , info )

计算 CSR 格式的稀疏矩阵的不完全 Cholesky 分解，填充为 0，没有旋转：op(A) = R**T * R。此方法必须遵循对 的调用csrsv_analysis()。矩阵A被上三角因子或下三角因子R或R**T覆盖。

参数：
  • trans – 应用于矩阵的操作
  • m – 矩阵的行数和列数
  • descr – 矩阵描述符
  • csrValA – A中非零值的向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • 信息——分析结果
返回：

没有任何
accelerate.cuda.sparse.Sparse.csrilu0( trans , m , descr , csrValA , csrRowPtrA , csrColIndA , info )

计算 CSR 格式的稀疏矩阵的不完全 LU 分解，填充为 0，没有旋转：op(A) = L * U。此方法必须遵循对 的调用 csrsv_analysis()。矩阵A被下三角因子和上三角因子L和U覆盖。

参数：
  • trans – 应用于矩阵的操作
  • m – 矩阵的行数和列数
  • descr – 矩阵描述符
  • csrValA – A中非零值的向量
  • csrRowPtrA – A的行指针向量
  • csrColIndA – A的列索引向量
  • 信息——分析结果
返回：

没有任何
accelerate.cuda.sparse.Sparse.gtsv( m , n , dl , d , du , B , ldb )

计算具有多个右侧的三对角线性系统的解：A * Y = alpha * X。

参数：
  • m – 线性系统的大小
  • n – 系统右侧的数量
  • dl – 存储下对角线元素的密集向量
  • d – 存储对角线元素的密集向量
  • du – 存储上对角元素的密集向量
  • B – 持有系统右侧的稠密矩阵
  • ldb – B的领先维度
返回：

没有任何
accelerate.cuda.sparse.Sparse.gtsv_nopivot( m , n , dl , d , du , B , ldb )

类似于gtsv()，但计算解而不执行任何旋转。

参数：
  • m – 线性系统的大小
  • n – 系统右侧的数量
  • dl – 存储下对角线元素的密集向量
  • d – 存储对角线元素的密集向量
  • du – 存储上对角元素的密集向量
  • B – 持有系统右侧的稠密矩阵
  • ldb – B的领先维度
返回：

没有任何
accelerate.cuda.sparse.Sparse.gtsvStridedBatch( m , dl , d , du , x , batchCount , batchStride )

计算i 个三对角线性系统的解：A(i) * y(i) = alpha * x(i)。

参数：
  • m – 线性系统的大小
  • dl – 存储每个系统的下对角线元素的堆叠密集向量
  • d – 存储每个系统对角线元素的堆叠密集向量
  • du – 存储每个系统的上对角元素的堆叠密集向量
  • x – 保存系统右侧的密集矩阵
  • batchCount – 要解决的系统数量
  • batchStride – 分隔每个系统向量的元素数量
返回：

没有任何

格式转换

accelerate.cuda.sparse.Sparse.bsr2csr( dirA , mb , nb , descrA , bsrValA , bsrRowPtrA , bsrColIndA , blockDim , descrC , csrValC , csrRowPtrC , csrColIndC )

将BSR 格式的稀疏矩阵A转换为 CSR 格式，存储在C 中。

参数：
  • dirA – 块存储的行 ('R') 或列 ('C') 方向
  • mb – A的块行数
  • nb – A的块列数
  • descrA – A 的矩阵描述符
  • bsrValA – A的非零值向量
  • bsrRowPtrA – A的块行指针向量
  • bsrColIndA – A的块列索引向量
  • blockDim – A 的块尺寸
  • descrC – C 的矩阵描述符
  • csrValA – C中非零值的向量
  • csrRowPtrA – C的行指针向量
  • csrColIndA – C的列索引向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.Xcoo2csr( cooRowInd , nnz , m , csrRowPtr )

将包含与 COO 格式对应的未压缩行索引的数组转换为与 CSR 格式对应的压缩行指针数组。

参数：
  • cooRowInd – 未压缩行索引的整数数组
  • nnz – 非零数
  • m – 矩阵行数
  • csrRowPtr – 要写入的行指针向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.csc2dense( m , n , descrA , cscValA , cscRowIndA , cscColPtrA , A , lda )

将CSC 格式的稀疏矩阵A转换为稠密矩阵。

参数：
  • m – A的行数
  • n – A的列数
  • descrA – A 的矩阵描述符
  • cscValA – A的 CSC 表示中的值
  • cscRowIndA – A的 CSC 表示中的行索引
  • cscColPtrA – A的 CSC 表示中的列指针
  • A –由该函数写入的A 的密集矩阵表示。
  • lda - A的领先维度
返回：

没有任何
accelerate.cuda.sparse.Sparse.Xcsr2bsrNnz( dirA , m , n , descrA , csrRowPtrA , csrColIndA , blockDim , descrC , bsrRowPtrC )

执行将 CSR 格式的矩阵转换为 BSR 格式所需的分析。

参数：
  • dirA – 块存储的行 ('R') 或列 ('C') 方向
  • m – 矩阵的行数
  • n – 矩阵的列数
  • descrA – 输入矩阵A 的矩阵描述符
  • csrRowPtrA – 矩阵的行指针
  • csrColIndA – 矩阵的列索引
  • blockDim – 输出矩阵C 的块维度
  • descrC – 输出矩阵C 的矩阵描述符
返回：

矩阵的非零数
accelerate.cuda.sparse.Sparse.csr2bsr( dirA , m , n , descrA , csrValA , csrRowPtrA , csrColIndA , blockDim , descrC , bsrValC , bsrRowPtrC , bsrColIndC )

将矩阵从 CSR 格式转换为 BSR 格式。

参数：
  • dirA – 块存储的行 ('R') 或列 ('C') 方向
  • m – 矩阵的行数
  • n – 矩阵的列数
  • descrA – 输入矩阵A 的矩阵描述符
  • csrValA – 矩阵的非零值
  • csrRowPtrA – 矩阵的行指针
  • csrColIndA – 矩阵的列索引
  • blockDim – 输出矩阵C 的块维度
  • descrC – 输出矩阵C 的矩阵描述符
  • bsrValC – 输出矩阵C 的非零值
  • bsrRowPtrC – 输出矩阵C 的块行指针
  • bsrColIndC – 输出矩阵C 的块列索引
返回：

矩阵的非零数
accelerate.cuda.sparse.Sparse.Xcsr2coo( csrRowPtr , nnz , m , cooRowInd )

将对应于 CSR 格式的压缩行指针数组转换为对应于 COO 格式的未压缩行索引数组。

参数：
  • csrRowPtr – 行指针向量
  • nnz – 非零数
  • m – 矩阵的行数
  • cooRowInd – 此函数写入的未压缩行索引向量
返回：

没有任何
accelerate.cuda.sparse.Sparse.csr2csc( m , n , nnz , csrVal , csrRowPtr , csrColInd , cscVal , cscRowInd , cscColPtr , copyValues )

将 CSR 格式的稀疏矩阵转换为 CSC 格式的稀疏矩阵。

参数：
  • m – 矩阵的行数
  • n – 矩阵的列数
  • nnz – 矩阵的非零数
  • csrVal – CSR 表示中的值
  • csrRowPtr – CSR 表示中的行索引
  • csrColInd – CSR 表示中的列指针
  • cscVal – CSC 表示中的值
  • cscRowInd – CSC 表示中的行索引
  • cscColPtr – CSC 表示中的列指针
  • copyValues – 'N'或'S'用于值的符号或数字副本
返回：

没有任何
accelerate.cuda.sparse.Sparse.csr2dense( m , n , descr , csrVal , csrRowPtr , csrColInd , A , lda )

将 CSR 格式的稀疏矩阵转换为密集格式。

参数：
  • m – 矩阵的行数
  • n – 矩阵的列数
  • descr – 矩阵描述符
  • csrVal – CSR 表示中的值
  • csrRowPtr – CSR 表示中的行索引
  • csrColInd – CSR 表示中的列指针
  • A – 此函数写入的密集表示
  • lda - 矩阵的前导维度
返回：

没有任何
accelerate.cuda.sparse.Sparse.dense2csc( m , n , descrA , A , lda , nnzPerCol , cscVal , cscRowInd , cscColPtr )

将密集矩阵转换为 CSC 格式的稀疏矩阵。该nnzPerCol 参数可以用一个呼叫来计算nnz()。

参数：
  • m – 矩阵的行数
  • n – 矩阵的列数
  • descrA – 矩阵描述符
  • A – 密集格式的矩阵
  • lda - 矩阵的前导维度
  • nnzPerCol – 包含每列非零元素数的数组
  • cscVal – CSC 表示中的值
  • cscRowInd – CSC 表示中的行索引
  • cscColPtr – CSC 表示中的列指针
返回：

没有任何
accelerate.cuda.sparse.Sparse.dense2csr( m , n , descrA , A , lda , nnzPerRow , csrVal , csrRowPtr , csrColInd )

将密集矩阵转换为 CSR 格式的稀疏矩阵。该nnzPerRow 参数可以用一个呼叫来计算nnz()。

参数：
  • m – 矩阵的行数
  • n – 矩阵的列数
  • descrA – 矩阵描述符
  • A – 密集格式的矩阵
  • lda - 矩阵的前导维度
  • nnzPerRow – 包含每行非零元素数的数组
  • csrVal – CSR 表示中的值
  • csrRowPtr – CSR 表示中的行索引
  • csrColInd – CSR 表示中的列指针
返回：

没有任何
accelerate.cuda.sparse.Sparse.nnz( dirA , m , n , descrA , A , lda , nnzPerRowCol )

计算密集矩阵每行或每列的非零元素数，以及矩阵中非零元素的总数。

参数：
  • dirA – 'R'表示每行的非零数，或'C'表示每列。
  • m – 矩阵的行数
  • n – 矩阵的列数
  • descrA – 矩阵描述符
  • A – 矩阵
  • lda - 矩阵的前导维度
  • nnzPerRowCol – 包含每行或每列非零值的数组
返回：

矩阵中非零的总数