muSPARSE API 参考

函数文档

函数 musparseSetMatDiagType

MUSPARSE_EXPORT musparseStatus_t musparseSetMatDiagType(
    musparseMatDescr_t descr,
    musparseDiagType_t diag_type
)

指定矩阵描述符的矩阵对角线类型。

参数：

descr 矩阵描述符。
diag_type MUSPARSE_DIAG_TYPE_UNIT 或 MUSPARSE_DIAG_TYPE_NON_UNIT。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER descr 指针无效。
MUSPARSE_STATUS_INVALID_VALUE diag_type 无效。

musparseSetMatDiagType 设置矩阵描述符的矩阵对角线类型。有效的对角线类型为 MUSPARSE_DIAG_TYPE_UNIT 或 MUSPARSE_DIAG_TYPE_NON_UNIT。

函数 musparseSetMatFillMode

MUSPARSE_EXPORT musparseStatus_t musparseSetMatFillMode(
    musparseMatDescr_t descr,
    musparseFillMode_t fill_mode
)

指定矩阵描述符的矩阵填充模式。

参数：

descr 矩阵描述符。
fill_mode MUSPARSE_FILL_MODE_LOWER 或 MUSPARSE_FILL_MODE_UPPER。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER descr 指针无效。
MUSPARSE_STATUS_INVALID_VALUE fill_mode 无效。

musparseSetMatFillMode 设置矩阵描述符的矩阵填充模式。有效的填充模式为 MUSPARSE_FILL_MODE_LOWER 或 MUSPARSE_FILL_MODE_UPPER。

函数 musparseSetMatIndexBase

MUSPARSE_EXPORT musparseStatus_t musparseSetMatIndexBase(
    musparseMatDescr_t descr,
    musparseIndexBase_t base
)

指定矩阵描述符的索引基。

参数：

descr 矩阵描述符。
base MUSPARSE_INDEX_BASE_ZERO 或 MUSPARSE_INDEX_BASE_ONE。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER descr 指针无效。
MUSPARSE_STATUS_INVALID_VALUE base 无效。

musparseSetMatIndexBase 设置矩阵描述符的索引基。有效选项为 MUSPARSE_INDEX_BASE_ZERO 或 MUSPARSE_INDEX_BASE_ONE。

函数 musparseXbsrsv_bufferSize

MUSPARSE_EXPORT musparseStatus_t musparseXbsrsv_bufferSize()

使用 BSR 存储格式的稀疏三角求解。

参数：

handle muSPARSE 库上下文队列的句柄。
dir BSR 块的矩阵存储方向。
trans 矩阵操作类型。
mb 稀疏 BSR 矩阵的块行数。
nnzb 稀疏 BSR 矩阵的非零块数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 稀疏 BSR 矩阵的 nnzb 块数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnz 数组。
block_dim 稀疏 BSR 矩阵的块维度。
info 在分析步骤中收集信息的结构体。
buffer_size musparseSbsrsv_analysis(), musparseDbsrsv_analysis(), musparseCbsrsv_analysis(), musparseZbsrsv_analysis(), musparseSbsrsv_solve(), musparseDbsrsv_solve(), musparseCbsrsv_solve() 和 musparseZbsrsv_solve() 所需的临时存储缓冲区的字节数。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr, bsr_col_ind, info 或 buffer_size 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

musparseXbsrsv_bufferSize 返回 musparseSbsrsv_analysis(), musparseDbsrsv_analysis(), musparseCbsrsv_analysis(), musparseZbsrsv_analysis(), musparseSbsrsv_solve(), musparseDbsrsv_solve(), musparseCbsrsv_solve() 和 musparseZbsrsv_solve() 所需的临时存储缓冲区的大小。临时存储缓冲区必须由用户分配。

musparseStatus_t musparseSbsrsv_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr, const float* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);

musparseStatus_t musparseDbsrsv_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr, const double* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);

musparseStatus_t musparseCbsrsv_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr,
    const muComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    size_t* buffer_size);

musparseStatus_t musparseZbsrsv_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr,
    const muDoubleComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    size_t* buffer_size);

函数 musparseXbsrsv_analysis

musparseStatus_t musparseXbsrsv_analysis()

使用 BSR 存储格式的稀疏三角求解。

参数：

handle muSPARSE 库上下文队列的句柄。
dir BSR 块的矩阵存储方向。
trans 矩阵操作类型。
mb 稀疏 BSR 矩阵的块行数。
nnzb 稀疏 BSR 矩阵的非零块数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 稀疏 BSR 矩阵的 nnzb 块数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnz 数组。
block_dim 稀疏 BSR 矩阵的块维度。
info 在分析步骤中收集信息的结构体。
analysis MUSPARSE_ANALYSIS_POLICY_REUSE 或 MUSPARSE_ANALYSIS_POLICY_FORCE。
solve MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_row_ptr, bsr_col_ind, info 或 temp_buffer 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

如果矩阵的稀疏模式发生变化，收集到的信息将变得无效。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseXbsrsv_analysis 为 musparseSbsrsv_solve(), musparseDbsrsv_solve(), musparseCbsrsv_solve() 和 musparseZbsrsv_solve() 执行分析步骤。预计此函数将仅对给定矩阵和特定操作类型执行一次。分析元数据可以通过 musparseXbsrsv_clear() 清除。

musparseXbsrsv_analysis 可以与其元数据共享 musparseSbsrsm_analysis(), musparseDbsrsm_analysis(), musparseCbsrsm_analysis(), musparseZbsrsm_analysis(), musparseSbsrilu0_analysis(), musparseDbsrilu0_analysis(), musparseCbsrilu0_analysis(), musparseZbsrilu0_analysis(), musparseSbsric0_analysis(), musparseDbsric0_analysis(), musparseCbsric0_analysis() 和 musparseZbsric0_analysis()。选择 MUSPARSE_ANALYSIS_POLICY_REUSE 策略可以大大提高元数据的计算性能。然而，用户需要确保稀疏模式保持不变。如果不能保证，必须使用 MUSPARSE_ANALYSIS_POLICY_FORCE。

musparseStatus_t musparseSbsrsv_analysis(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr, const float* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

musparseStatus_t musparseDbsrsv_analysis(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr, const double* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

musparseStatus_t musparseCbsrsv_analysis(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr,
    const muComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);

musparseStatus_t musparseZbsrsv_analysis(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const musparseMatDescr_t descr,
    const muDoubleComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);

函数 musparseXbsrsv_solve

MUSPARSE_EXPORT musparseStatus_t musparseXbsrsv_solve()

使用 BSR 存储格式的稀疏三角求解。

参数：

handle muSPARSE 库上下文队列的句柄。
dir BSR 块的矩阵存储方向。
trans 矩阵操作类型。
mb 稀疏 BSR 矩阵的块行数。
nnzb 稀疏 BSR 矩阵的非零块数。
alpha 标量 $\alpha$ 。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 稀疏 BSR 矩阵的 nnzb 块数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnz 数组。
block_dim 稀疏 BSR 矩阵的块维度。
info 在分析步骤中收集信息的结构体。
x 包含右手边的 m 元素数组。
y 包含解的 m 元素数组。
policy MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, alpha, bsr_val, bsr_row_ptr, bsr_col_ind, x 或 y 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_ARCH_MISMATCH 设备不受支持。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

稀疏 BSR 矩阵必须是排序的。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。
目前，仅支持 trans == MUSPARSE_OPERATION_NON_TRANSPOSE 和 trans == MUSPARSE_OPERATION_TRANSPOSE。

示例：

考虑以 BSR 存储格式存储的下三角 $m \times m$ 矩阵 $L$ ，对角线为单位。以下示例解决 $L \cdot y = x$ 。

// 创建 musparse 句柄
musparseHandle_t handle;
musparseCreate(&handle);

// 创建矩阵描述符
musparseMatDescr_t descr;
musparseCreateMatDescr(&descr);
musparseSetMatFillMode(descr, MUSPARSE_FILL_MODE_LOWER);
musparseSetMatDiagType(descr, MUSPARSE_DIAG_TYPE_UNIT);

// 创建矩阵信息结构
musparseMatInfo_t info;
musparseCreateMatInfo(&info);

// 获取所需的缓冲区大小
size_t buffer_size;
musparseDbsrsv_bufferSize(handle,
                             MUSPARSE_DIRECTION_COLUMN,
                             MUSPARSE_OPERATION_NON_TRANSPOSE,
                             mb,
                             nnzb,
                             descr,
                             bsr_val,
                             bsr_row_ptr,
                             bsr_col_ind,
                             block_dim,
                             info,
                             &buffer_size);

// 分配临时缓冲区
void* temp_buffer;
musaMalloc(&temp_buffer, buffer_size);

// 执行分析步骤
musparseDbsrsv_analysis(handle,
                          MUSPARSE_DIRECTION_COLUMN,
                          MUSPARSE_OPERATION_NON_TRANSPOSE,
                          mb,
                          nnzb,
                          descr,
                          bsr_val,
                          bsr_row_ptr,
                          bsr_col_ind,
                          block_dim,
                          info,
                          MUSPARSE_ANALYSIS_POLICY_REUSE,
                          MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                          temp_buffer);

// 解决 Ly = x
musparseDbsrsv_solve(handle,
                       MUSPARSE_DIRECTION_COLUMN,
                       MUSPARSE_OPERATION_NON_TRANSPOSE,
                       mb,
                       nnzb,
                       &alpha,
                       descr,
                       bsr_val,
                       bsr_row_ptr,
                       bsr_col_ind,
                       block_dim,
                       info,
                       x,
                       y,
                       MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                       temp_buffer);

// 应该没有发现零主元，因为 L 有单位对角线

// 清理
musaFree(temp_buffer);
musparseDestroyMatInfo(info);
musparseDestroyMatDescr(descr);
musparseDestroy(handle);

musparseXbsrsv_solve 解决一个稀疏三角线性系统，一个定义在 BSR 存储格式的稀疏 $m \times m$ 矩阵，一个密集解向量 $y$ 和乘以 $\alpha$ 的右手边 $x$ ，使得：

op(A) \cdot y = \alpha \cdot x,

其中

op(A) = \begin{cases} A & \text{if } \text{trans} = \text{MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \\ A^T & \text{if } \text{trans} = \text{MUSPARSE\_OPERATION\_TRANSPOSE} \\ A^H & \text{if } \text{trans} = \text{MUSPARSE\_OPERATION\_CONJUGATE\_TRANSPOSE} \end{cases}

musparseXbsrsv_solve() 需要用户分配的临时缓冲区。其大小由 musparseSbsrsv_bufferSize(), musparseDbsrsv_bufferSize(), musparseCbsrsv_bufferSize() 或 musparseZbsrsv_bufferSize() 返回。此外，需要分析元数据。可以通过 musparseSbsrsv_analysis(), musparseDbsrsv_analysis(), musparseCbsrsv_analysis() 或 musparseZbsrsv_analysis() 获得。musparseXbsrsv_solve 报告第一个零主元（数值或结构零）。零主元状态可以通过调用 musparseXbsrsv_zeroPivot() 检查。如果 musparseDiagType_t == MUSPARSE_DIAG_TYPE_UNIT，则即使 $A_{j,j} = 0$ 对于某些 $j$ ，也不会报告零主元。

musparseStatus_t musparseSbsrsv_solve(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const float* alpha, const musparseMatDescr_t descr,
    const float* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, const float* x, float* y,
    musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseDbsrsv_solve(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const double* alpha, const musparseMatDescr_t descr,
    const double* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, const double* x, double* y,
    musparseSolvePolicy_t policy, void* temp_buffer);
  
musparseStatus_t musparseCbsrsv_solve(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const muComplex* alpha,
    const musparseMatDescr_t descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, const muComplex* x, muComplex* y,
    musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseZbsrsv_solve(
    musparseHandle_t handle, musparseDirection_t dir, musparseOperation_t trans,
    muInt mb, muInt nnzb, const muDoubleComplex* alpha,
    const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, const muDoubleComplex* x, muDoubleComplex* y,
    musparseSolvePolicy_t policy, void* temp_buffer);

函数 musparseXbsrsv_zeroPivot

MUSPARSE_EXPORT musparseStatus_t musparseXbsrsv_zeroPivot(
    musparseHandle_t handle,
    musparseMatInfo_t info,
    muInt * position
)

使用 BSR 存储格式的稀疏三角求解。

参数：

handle muSPARSE 库上下文队列的句柄。
info 在分析步骤中收集信息的结构体。
position 零主元 $j$ 的指针，可以位于主机或设备内存中。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info 或 position 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT 发现零主元。

注意：musparseXbsrsv_zeroPivot 是一个阻塞函数。它可能会对性能产生负面影响。

musparseXbsrsv_zeroPivot 返回 MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT，如果在 musparseSbsrsv_solve(), musparseDbsrsv_solve(), musparseCbsrsv_solve() 或 musparseZbsrsv_solve() 计算期间发现结构或数值零。第一个零主元 $j$ 在 $A_{j,j}$ 存储在 position 中，使用与 BSR 矩阵相同的索引基。

musparseXbsrsv_zeroPivot 返回 MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT 如果在 musparseSbsrsv_solve(), musparseDbsrsv_solve(), musparseCbsrsv_solve(), 或 musparseZbsrsv_solve() 计算期间发现结构或数值零。第一个零主元 $j$ 在 $A_{j,j}$ 存储在 position 中，使用与 BSR 矩阵相同的索引基。

position 可以位于主机或设备内存中。如果没有发现零主元，position 设置为 -1，并且返回MUSPARSE_STATUS_SUCCESS。

函数 musparseXbsrsm_bufferSize

MUSPARSE_EXPORT musparseStatus_t musparseXbsrsm_bufferSize()

使用 BSR 存储格式的稀疏三角系统求解。

参数：

handle muSPARSE 库上下文队列的句柄。
dir BSR 块的矩阵存储方向。
trans_A 矩阵 A 操作类型。
trans_X 矩阵 X 操作类型。
mb 稀疏 BSR 矩阵 A 的块行数。
nrhs 密集矩阵 op(X) 的列数。
nnzb 稀疏 BSR 矩阵 A 的非零块数。
descr 稀疏 BSR 矩阵 A 的描述符。
bsr_val 稀疏 BSR 矩阵的 nnzb 块数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnzb 数组。
block_dim 稀疏 BSR 矩阵的块维度。
info 在分析步骤中收集信息的结构体。
buffer_size musparseSbsrsm_analysis(), musparseDbsrsm_analysis(), musparseCbsrsm_analysis(), musparseZbsrsm_analysis(), musparseSbsrsm_solve(), musparseDbsrsm_solve(), musparseCbsrsm_solve() 和 musparseZbsrsm_solve() 所需的临时存储缓冲区的字节数。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nrhs, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr, bsr_col_ind, info 或 buffer_size 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans_A == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE, trans_X == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

musparseXbsrsm_bufferSize 返回 musparseSbsrsm_analysis(), musparseDbsrsm_analysis(), musparseCbsrsm_analysis(), musparseZbsrsm_analysis(), musparseSbsrsm_solve(), musparseDbsrsm_solve(), musparseCbsrsm_solve() 和 musparseZbsrsm_solve() 所需的临时存储缓冲区的大小。临时存储缓冲区必须由用户分配。

musparseStatus_t musparseSbsrsm_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const float* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, size_t* buffer_size);
 
musparseStatus_t musparseDbsrsm_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const double* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, size_t* buffer_size);
 
musparseStatus_t musparseCbsrsm_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const muComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    size_t* buffer_size);
 
musparseStatus_t musparseZbsrsm_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const muDoubleComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    size_t* buffer_size);

函数 musparseXbsrsm_analysis

MUSPARSE_EXPORT musparseStatus_t musparseXbsrsm_analysis()

使用 BSR 存储格式的稀疏三角系统求解。

参数：

handle muSPARSE 库上下文队列的句柄。
dir BSR 块的矩阵存储方向。
trans_A 矩阵 A 操作类型。
trans_X 矩阵 X 操作类型。
mb 稀疏 BSR 矩阵 A 的块行数。
nrhs 密集矩阵 op(X) 的列数。
nnzb 稀疏 BSR 矩阵 A 的非零块数。
descr 稀疏 BSR 矩阵 A 的描述符。
bsr_val 稀疏 BSR 矩阵的 nnzb 块数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnzb 数组。
block_dim 稀疏 BSR 矩阵的块维度。
info 在分析步骤中收集信息的结构体。
analysis MUSPARSE_ANALYSIS_POLICY_REUSE 或 MUSPARSE_ANALYSIS_POLICY_FORCE。
solve MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nrhs, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr, bsr_col_ind, info 或 temp_buffer 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans_A == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE, trans_X == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

如果矩阵的稀疏模式发生变化，收集到的信息将变得无效。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseXbsrsm_analysis 为 musparseSbsrsm_solve(), musparseDbsrsm_solve(), musparseCbsrsm_solve() 和 musparseZbsrsm_solve() 执行分析步骤。预计此函数将仅对给定矩阵和特定操作类型执行一次。分析元数据可以通过 musparseXbsrsm_clear() 清除。

musparseXbsrsm_analysis 可以与其元数据共享 musparseSbsrilu0_analysis(), musparseDbsrilu0_analysis(), musparseCbsrilu0_analysis(), musparseZbsrilu0_analysis(), musparseSbsric0_analysis(), musparseDbsric0_analysis(), musparseCbsric0_analysis(), musparseZbsric0_analysis(), musparseSbsrsv_analysis(), musparseDbsrsv_analysis(), musparseCbsrsv_analysis() 和 musparseZbsrsv_analysis()。选择 MUSPARSE_ANALYSIS_POLICY_REUSE 策略可以大大提高元数据的计算性能。然而，用户需要确保稀疏模式保持不变。如果不能保证，必须使用 MUSPARSE_ANALYSIS_POLICY_FORCE。

musparseStatus_t musparseSbsrsm_analysis(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const float* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);
 
musparseStatus_t musparseDbsrsm_analysis(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const double* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);
 
musparseStatus_t musparseCbsrsm_analysis(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const muComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);
 
musparseStatus_t musparseZbsrsm_analysis(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const musparseMatDescr_t descr,
    const muDoubleComplex* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);

函数 musparseXbsrsm_solve

MUSPARSE_EXPORT musparseStatus_t musparseXbsrsm_solve()

使用 BSR 存储格式的稀疏三角系统求解。

参数：

handle muSPARSE 库上下文队列的句柄。
dir BSR 块的矩阵存储方向。
trans_A 矩阵 A 操作类型。
trans_X 矩阵 X 操作类型。
mb 稀疏 BSR 矩阵 A 的块行数。
nrhs 密集矩阵 op(X) 的列数。
nnzb 稀疏 BSR 矩阵 A 的非零块数。
alpha 标量 $\alpha$ 。
descr 稀疏 BSR 矩阵 A 的描述符。
bsr_val 稀疏 BSR 矩阵的 nnzb 块数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnzb 数组。
block_dim 稀疏 BSR 矩阵的块维度。
info 在分析步骤中收集信息的结构体。
B 右手边矩阵 B，领先维度为 ldb。
ldb 右手边矩阵 B 的领先维度。
X 解矩阵 X，领先维度为 ldx。
ldx 解矩阵 X 的领先维度。
policy MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nrhs, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER alpha, descr, bsr_val, bsr_row_ptr, bsr_col_ind, B, X, info 或 temp_buffer 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans_A == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE, trans_X == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

稀疏 BSR 矩阵必须是排序的。
B 和 X 的操作类型必须匹配，如果 $op(B)=B, op(X)=X$ 。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。
目前，仅支持 trans_A != MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 和 trans_X != MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE。

musparseXbsrsm_solve 解决一个稀疏三角线性系统，一个定义在 BSR 存储格式的稀疏 $m \times m$ 矩阵，一个密集解矩阵 X 和乘以 $\alpha$ 的右手边矩阵 B，使得

op(A) \cdot op(X) = \alpha \cdot op(B),

其中

op(A) = \begin{cases} A, & \text{if trans\_A == MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \\ A^T, & \text{if trans\_A == MUSPARSE\_OPERATION\_TRANSPOSE} \\ A^H, & \text{if trans\_A == MUSPARSE\_OPERATION\_CONJUGATE\_TRANSPOSE} \end{cases}

和

op(X) = \begin{cases} X, & \text{if trans\_X == MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \\ X^T, & \text{if trans\_X == MUSPARSE\_OPERATION\_TRANSPOSE} \\ X^H, & \text{if trans\_X == MUSPARSE\_OPERATION\_CONJUGATE\_TRANSPOSE} \end{cases}

musparseXbsrsm_solve 需要用户分配的临时缓冲区。其大小由 musparseSbsrsm_bufferSize(), musparseDbsrsm_bufferSize(), musparseCbsrsm_bufferSize() 或 musparseZbsrsm_bufferSize() 返回。此外，需要分析元数据。可以通过 musparseSbsrsm_analysis(), musparseDbsrsm_analysis(), musparseCbsrsm_analysis() 或 musparseZbsrsm_analysis() 获得。musparseXbsrsm_solve 报告第一个零主元（数值或结构零）。零主元状态可以通过调用 [musparseXbsrsm_zeroPivot()] 检查。如果 musparseDiagType_t == MUSPARSE_DIAG_TYPE_UNIT, 则即使 $A_{j,j} = 0$ 对于某些 $j$ ，也不会报告零主元。

musparseStatus_t musparseSbsrsm_solve(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const float* alpha, const musparseMatDescr_t descr,
    const float* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, const float* B, muInt ldb,
    float* X, muInt ldx, musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseDbsrsm_solve(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const double* alpha, const musparseMatDescr_t descr,
    const double* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, musparseMatInfo_t info, const double* B, muInt ldb,
    double* X, muInt ldx, musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseCbsrsm_solve(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const muComplex* alpha,
    const musparseMatDescr_t descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, const muComplex* B, muInt ldb, muComplex* X,
    muInt ldx, musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseZbsrsm_solve(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_X, muInt mb,
    muInt nrhs, muInt nnzb, const muDoubleComplex* alpha,
    const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, const muDoubleComplex* B, muInt ldb,
    muDoubleComplex* X, muInt ldx, musparseSolvePolicy_t policy,
    void* temp_buffer);

函数 musparseXbsrsm_zeroPivot

MUSPARSE_EXPORT musparseStatus_t musparseXbsrsm_zeroPivot(
    musparseHandle_t handle,
    musparseMatInfo_t info,
    muInt * position
)

使用 BSR 存储格式的稀疏三角系统求解。

参数：

handle muSPARSE 库上下文队列的句柄。
info 在分析步骤中收集信息的结构体。
position 零主元 $j$ 的指针，可以位于主机或设备内存中。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info 或 position 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT 发现零主元。

注意：musparseXbsrsm_zeroPivot 是一个阻塞函数。它可能会对性能产生负面影响。

musparseXbsrsm_zeroPivot 返回 MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT，如果在 musparseSbsrsm_solve(), musparseDbsrsm_solve(), musparseCbsrsm_solve() 或 musparseZbsrsm_solve() 计算期间发现结构或数值零。第一个零主元 $j$ 在 $A_{j,j}$ 存储在 position 中，使用与 BSR 矩阵相同的索引基。

position 可以位于主机或设备内存中。如果没有发现零主元，position 设置为 -1，并且返回 MUSPARSE_STATUS_SUCCESS。

函数 musparseXbsrilu0_numericBoost

MUSPARSE_EXPORT musparseStatus_t musparseXbsrilu0_numericBoost()

使用 BSR 存储格式的不完全 LU 分解，0 填充且无主元。

参数：

handle muSPARSE 库上下文队列的句柄。
info 在分析步骤中收集信息的结构体。
enable_boost 启用/禁用数值提升。
boost_tol 确定是否替换数值的容差。
boost_val 替换数值的值。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info, tol 或 boost_val 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。

注意：

通过将 enable_boost 设置为 1 启用提升值，通过将 enable_boost 设置为 0 禁用提升值。
tol 和 boost_val 可以位于主机或设备内存中。

musparseXbsrilu0_numericBoost 允许用户在不完全 LU 分解中替换数值。tol 用于确定是否用 boost_val 替换数值，使得 $A_{j,j} = \text{boost\_val}$ 如果 $\, \text{tol} \ge \left| A_{j,j} \right|.$

musparseStatus_t musparseSbsrilu0_numericBoost(musparseHandle_t handle,
                                               musparseMatInfo_t info,
                                               int enable_boost,
                                               const float* boost_tol,
                                               const float* boost_val);
 
musparseStatus_t musparseDbsrilu0_numericBoost(musparseHandle_t handle,
                                               musparseMatInfo_t info,
                                               int enable_boost,
                                               const double* boost_tol,
                                               const double* boost_val);
 
musparseStatus_t musparseCbsrilu0_numericBoost(musparseHandle_t handle,
                                               musparseMatInfo_t info,
                                               int enable_boost,
                                               const float* boost_tol,
                                               const muComplex* boost_val);
 
musparseStatus_t musparseZbsrilu0_numericBoost(
    musparseHandle_t handle, musparseMatInfo_t info, int enable_boost,
    const double* boost_tol, const muDoubleComplex* boost_val);
 
musparseStatus_t musparseDSbsrilu0_numericBoost(musparseHandle_t handle,
                                                musparseMatInfo_t info,
                                                int enable_boost,
                                                const double* boost_tol,
                                                const float* boost_val);
 
musparseStatus_t musparseDCbsrilu0_numericBoost(musparseHandle_t handle,
                                                musparseMatInfo_t info,
                                                int enable_boost,
                                                const double* boost_tol,
                                                const muComplex* boost_val);

函数 musparseXbsrilu0_bufferSize

MUSPARSE_EXPORT musparseStatus_t musparseXbsrilu0_bufferSize()

使用 BSR 存储格式的不完全 LU 分解，0 填充且无主元。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 指定按 MUSPARSE_DIRECTION_ROW 或按 MUSPARSE_DIRECTION_COLUMN 计数非零元素的方向。
mb 稀疏 BSR 矩阵中的块行数。
nnzb 稀疏 BSR 矩阵中的非零块条目数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 包含稀疏 BSR 矩阵值的 nnzb*block_dim*block_dim 长度数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnzb 元素数组。
block_dim BSR 矩阵的块维度。在 1 和 m 之间，其中 m=mb*block_dim。
info 在分析步骤中收集信息的结构体。
buffer_size musparseSbsrilu0_analysis(), musparseDbsrilu0_analysis(), musparseCbsrilu0_analysis(), musparseZbsrilu0_analysis(), musparseSbsrilu0(), musparseDbsrilu0(), musparseCbsrilu0() 和 musparseZbsrilu0() 所需的临时存储缓冲区的字节数。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr, bsr_col_ind, info 或 buffer_size 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

musparseXbsrilu0_bufferSize 返回 musparseSbsrilu0_analysis(), musparseDbsrilu0_analysis(), musparseCbsrilu0_analysis(), musparseZbsrilu0_analysis(), musparseSbsrilu0(), musparseDbsrilu0(), musparseSbsrilu0() 和 musparseDbsrilu0() 所需的临时存储缓冲区的大小。临时存储缓冲区必须由用户分配。临时存储缓冲区的大小与 musparseSbsrsv_bufferSize(), musparseDbsrsv_bufferSize(), musparseCbsrsv_bufferSize(), musparseZbsrsv_bufferSize(), musparseSbsric0_bufferSize(), musparseDbsric0_bufferSize(), musparseCbsric0_bufferSize() 和 musparseZbsric0_bufferSize() 返回的大小相同，如果矩阵的稀疏模式相同。因此，用户分配的缓冲区可以在对这些函数的后续调用之间共享。

musparseStatus_t musparseSbsrilu0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const float* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);
 
musparseStatus_t musparseDbsrilu0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const double* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);
 
musparseStatus_t musparseCbsrilu0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);
 
musparseStatus_t musparseZbsrilu0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);

函数 musparseXbsrilu0_analysis

MUSPARSE_EXPORT musparseStatus_t musparseXbsrilu0_analysis()

使用 BSR 存储格式的不完全 LU 分解，0 填充且无主元。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 指定按 MUSPARSE_DIRECTION_ROW 或按 MUSPARSE_DIRECTION_COLUMN 计数非零元素的方向。
mb 稀疏 BSR 矩阵中的块行数。
nnzb 稀疏 BSR 矩阵中的非零块条目数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 包含稀疏 BSR 矩阵值的 nnzb*block_dim*block_dim 长度数组。
bsr_row_ptr 指向稀疏 BSR 矩阵每个块行开始的 mb+1 元素数组。
bsr_col_ind 包含稀疏 BSR 矩阵块列索引的 nnzb 元素数组。
block_dim BSR 矩阵的块维度。在 1 和 m 之间，其中 m=mb*block_dim。
info 在分析步骤中收集信息的结构体。
analysis MUSPARSE_ANALYSIS_POLICY_REUSE 或 MUSPARSE_ANALYSIS_POLICY_FORCE。
solve MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 图书馆上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr, bsr_col_ind, info 或 temp_buffer 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

如果矩阵的稀疏模式发生变化，收集到的信息将变得无效。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseXbsrilu0_analysis 为 musparseSbsrilu0() musparseDbsrilu0(), musparseCbsrilu0(), 和 musparseZbsrilu0() 执行分析步骤。预计此函数将仅对给定矩阵执行一次。分析元数据可以通过 musparseXbsrilu0_clear() 清除。

musparseXbsrilu0_analysis 可以与其元数据共享 musparseSbsric0_analysis(), musparseDbsric0_analysis(), musparseCbsric0_analysis(), musparseZbsric0_analysis(), musparseSbsrsv_analysis(), musparseDbsrsv_analysis(), musparseCbsrsv_analysis(), musparseZbsrsv_analysis(), musparseSbsrsm_analysis(), musparseDbsrsm_analysis(), musparseCbsrsm_analysis() 和 musparseZbsrsm_analysis()。选择 MUSPARSE_ANALYSIS_POLICY_REUSE 策略可以大大提高元数据的计算性能。然而，用户需要确保稀疏模式保持不变。如果不能保证，必须使用 MUSPARSE_ANALYSIS_POLICY_FORCE。

musparseStatus_t musparseSbsrilu0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const float* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);
 
musparseStatus_t musparseDbsrilu0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const double* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);
 
musparseStatus_t musparseCbsrilu0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);
 
musparseStatus_t musparseZbsrilu0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

函数 musparseXbsrilu0

musparseStatus_t musparseXbsrilu0()

使用 BSR 存储格式进行不完全 LU 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 方向，指定是按 MUSPARSE_DIRECTION_ROW 还是按 MUSPARSE_DIRECTION_COLUMN 计数非零元素。
mb 稀疏 BSR 矩阵的块行数。
nnzb 稀疏 BSR 矩阵的非零块条目数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 长度为 nnzb*block_dim*block_dim 的数组，包含稀疏 BSR 矩阵的值。
bsr_row_ptr 长度为 mb+1 的数组，指向稀疏 BSR 矩阵每个块行的起始位置。
bsr_col_ind 长度为 nnzb 的数组，包含稀疏 BSR 矩阵的块列索引。
block_dim BSR 矩阵的块维度。在 1 和 m 之间，其中 m=mb*block_dim。
info 结构体，存储分析步骤中收集的信息。
policy MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb, 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr 或 bsr_col_ind 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_ARCH_MISMATCH 设备不支持。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

示例：

考虑存储在 BSR 存储格式中的稀疏 $m \times m$ 矩阵 $A$ 。以下示例计算不完全 LU 分解 $M \approx LU$ 并求解预条件系统 $My = x$ 。

     // 创建 musparse 句柄
     musparseHandle_t handle;
     musparseCreate(&handle);
   
     // 为 M 创建矩阵描述符
     musparseMatDescr_t descr_M;
     musparseCreateMatDescr(&descr_M);
   
     // 为 L 创建矩阵描述符
     musparseMatDescr_t descr_L;
     musparseCreateMatDescr(&descr_L);
     musparseSetMatFillMode(descr_L, MUSPARSE_FILL_MODE_LOWER);
     musparseSetMatDiagType(descr_L, MUSPARSE_DIAG_TYPE_UNIT);
   
     // 为 U 创建矩阵描述符
     musparseMatDescr_t descr_U;
     musparseCreateMatDescr(&descr_U);
     musparseSetMatFillMode(descr_U, MUSPARSE_FILL_MODE_UPPER);
     musparseSetMatDiagType(descr_U, MUSPARSE_DIAG_TYPE_NON_UNIT);
   
     // 创建矩阵信息结构
     musparseMatInfo_t info;
     musparseCreateMatInfo(&info);
   
     // 获取所需的缓冲区大小
     size_t buffer_size_M;
     size_t buffer_size_L;
     size_t buffer_size_U;
     musparseDbsrilu0_bufferSize(handle,
                                    MUSPARSE_DIRECTION_ROW,
                                    mb,
                                    nnzb,
                                    descr_M,
                                    bsr_val,
                                    bsr_row_ptr,
                                    bsr_col_ind,
                                    block_dim,
                                    info,
                                    &buffer_size_M);
     musparseDbsrsv_bufferSize(handle,
                                  MUSPARSE_DIRECTION_ROW,
                                  MUSPARSE_OPERATION_NON_TRANSPOSE,
                                  mb,
                                  nnzb,
                                  descr_L,
                                  bsr_val,
                                  bsr_row_ptr,
                                  bsr_col_ind,
                                  block_dim,
                                  info,
                                  &buffer_size_L);
     musparseDbsrsv_bufferSize(handle,
                                  MUSPARSE_DIRECTION_ROW,
                                  MUSPARSE_OPERATION_TRANSPOSE,
                                  mb,
                                  nnzb,
                                  descr_U,
                                  bsr_val,
                                  bsr_row_ptr,
                                  bsr_col_ind,
                                  block_dim,
                                  info,
                                  &buffer_size_U);
   
     size_t buffer_size = max(buffer_size_M, max(buffer_size_L,
buffer_size_U));

     // 分配临时缓冲区
     void* temp_buffer;
     musaMalloc(&temp_buffer, buffer_size);
   
     // 执行分析步骤，使用 MUSPARSE_ANALYSIS_POLICY_REUSE 来
提高
     // 计算性能
     musparseDbsrilu0_analysis(handle,
                                 MUSPARSE_DIRECTION_ROW,
                                 mb,
                                 nnzb,
                                 descr_M,
                                 bsr_val,
                                 bsr_row_ptr,
                                 bsr_col_ind,
                                 block_dim,
                                 info,
                                 MUSPARSE_ANALYSIS_POLICY_REUSE,
                                 MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                                 temp_buffer);
     musparseDbsrsv_analysis(handle,
                               MUSPARSE_DIRECTION_ROW,
                               MUSPARSE_OPERATION_NON_TRANSPOSE,
                               mb,
                               nnzb,
                               descr_L,
                               bsr_val,
                               bsr_row_ptr,
                               bsr_col_ind,
                               block_dim,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);
     musparseDbsrsv_analysis(handle,
                               MUSPARSE_DIRECTION_ROW,
                               MUSPARSE_OPERATION_TRANSPOSE,
                               mb,
                               nnzb,
                               descr_U,
                               bsr_val,
                               bsr_row_ptr,
                               bsr_col_ind,
                               block_dim,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);

     // 检查零主元
     muInt position;
     if(MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT == musparseXbsrilu0_zeroPivot(handle,
                                                                   info,
&position))
     {
         printf("A 在 A(%d,%d) 处有结构零\n", position, position);
     }

     // 计算不完全 LU 分解 M = LU
     musparseDbsrilu0(handle,
                        MUSPARSE_DIRECTION_ROW,
                        mb,
                        nnzb,
                        descr_M,
                        bsr_val,
                        bsr_row_ptr,
                        bsr_col_ind,
                        block_dim,
                        info,
                        MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                        temp_buffer);
   
     // 检查零主元
     if(MUSPARSE_EXPORT
MUSPARSE_STATUS_ZERO_PIVOT == musparseXbsrilu0_zeroPivot(handle,
                                                                    info,
&position))
     {
         printf("L 在 L(%d,%d) 处有结构和/或数值零\n",
                position,
                position);
     }

     // 解 Lz = x
     musparseDbsrsv_solve(handle,
                            MUSPARSE_DIRECTION_ROW,
                            MUSPARSE_OPERATION_NON_TRANSPOSE,
                            mb,
                            nnzb,
                            &alpha,
                            descr_L,
                            bsr_val,
                            bsr_row_ptr,
                            bsr_col_ind,
                            block_dim,
                            info,
                            x,
                            z,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 解 Uy = z
     musparseDbsrsv_solve(handle,
                            MUSPARSE_DIRECTION_ROW,
                            MUSPARSE_OPERATION_TRANSPOSE,
                            mb,
                            nnzb,
                            &alpha,
                            descr_U,
                            bsr_val,
                            bsr_row_ptr,
                            bsr_col_ind,
                            block_dim,
                            info,
                            z,
                            y,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 清理
     musaFree(temp_buffer);
     musparseDestroyMatInfo(info);
     musparseDestroyMatDescr(descr_M);
     musparseDestroyMatDescr(descr_L);
     musparseDestroyMatDescr(descr_U);
     musparseDestroy(handle);

musparseXbsrilu0 计算稀疏 $mb \times mb$ BSR 矩阵 $A$ 的不完全 LU 分解，不进行填零和不进行主元选取，使得 $A \approx LU$

musparseXbsrilu0 需要用户分配的临时缓冲区。其大小由 musparseSbsrilu0_bufferSize(), musparseDbsrilu0_bufferSize(), musparseCbsrilu0_bufferSize() 或 musparseZbsrilu0_bufferSize() 返回。此外，需要分析元数据。可以通过 musparseSbsrilu0_analysis(), musparseDbsrilu0_analysis(), musparseCbsrilu0_analysis() 或 musparseZbsrilu0_analysis() 获取。musparseXbsrilu0 报告第一个零主元（无论是数值零还是结构零）。零主元状态可以通过调用 musparseXbsrilu0_zeroPivot() 获取。

musparseStatus_t musparseSbsrilu0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, float* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseDbsrilu0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, double* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseCbsrilu0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);
 
musparseStatus_t musparseZbsrilu0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

函数 musparseXbsrilu0_zeroPivot

MUSPARSE_EXPORT musparseStatus_t musparseXbsrilu0_zeroPivot(
    musparseHandle_t handle,
    musparseMatInfo_t info,
    muInt * position
)

使用 BSR 存储格式进行不完全 LU 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
info 结构体，存储分析步骤中收集的信息。
position 指向零主元 $j$ 的指针，可以位于主机或设备内存中。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info 或 position 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT 发现零主元。

注意：

如果发现零主元，position $=j$ 表示对角块 $A_{j,j}$ 缺失（结构零）或对角块 $A_{j,j}$ 不可逆（数值零）。
musparseXbsrilu0_zeroPivot 是一个阻塞函数。它可能会对性能产生负面影响。

musparseXbsrilu0_zeroPivot 返回 MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT，如果在 musparseSbsrilu0(), musparseDbsrilu0(), musparseCbsrilu0() 或 musparseZbsrilu0() 计算期间发现结构零或数值零。第一个零主元 $j$ 在 $A_{j,j}$ 处存储在 position 中，使用与 BSR 矩阵相同的索引基。

position 可以位于主机或设备内存中。如果没有发现零主元，position 设置为 -1，并且返回MUSPARSE_STATUS_SUCCESS。

函数 musparseCreate

MUSPARSE_EXPORT musparseStatus_t musparseCreate(
    musparseHandle_t * handle
)

创建一个 musparse 句柄。

参数：

handle 指向 muSPARSE 库上下文的句柄的指针。

返回值：

MUSPARSE_STATUS_SUCCESS 初始化成功。
MUSPARSE_STATUS_INVALID_HANDLE handle 指针无效。
MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。

musparseCreate 创建 muSPARSE 库上下文。在调用任何其他 musparse API 函数之前必须先初始化，并在所有后续库函数调用中传递句柄。最后，句柄应该使用 musparseDestroy() 销毁。

函数 musparseDestroy

MUSPARSE_EXPORT musparseStatus_t musparseDestroy(
    musparseHandle_t handle
)

销毁一个 musparse 句柄。

参数：

handle muSPARSE 库上下文的句柄。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE handle 无效。
MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。

musparseDestroy 销毁 muSPARSE 库上下文并释放 muSPARSE 库使用的所有资源。

函数 musparseCreateMatDescr

MUSPARSE_EXPORT musparseStatus_t musparseCreateMatDescr(
    musparseMatDescr_t * descr
)

创建一个矩阵描述符。

参数：

descr 指向矩阵描述符的指针。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER descr 指针无效。

musparseCreateMatDescr 创建一个矩阵描述符。它将 musparseMatrixType_t 初始化为 MUSPARSE_MATRIX_TYPE_GENERAL，并将 musparseIndexBase_t 初始化为 MUSPARSE_INDEX_BASE_ZERO。最后，应该使用 musparseDestroyMatDescr() 销毁它。

函数 musparseDestroyMatDescr

MUSPARSE_EXPORT musparseStatus_t musparseDestroyMatDescr(
    musparseMatDescr_t descr
)

销毁一个矩阵描述符。

参数：

descr 矩阵描述符。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER descr 无效。

musparseDestroyMatDescr 销毁一个矩阵描述符并释放描述符使用的所有资源。

函数 musparseGetMatDiagType

musparseDiagType_t musparseGetMatDiagType(
    const musparseMatDescr_t descr
)

获取矩阵描述符的矩阵对角线类型。

参数：

descr 矩阵描述符。

返回值：MUSPARSE_DIAG_TYPE_UNIT 或 MUSPARSE_DIAG_TYPE_NON_UNIT。

musparseGetMatDiagType 返回矩阵描述符的矩阵对角线类型。

函数 musparseGetMatFillMode

musparseFillMode_t musparseGetMatFillMode(
    const musparseMatDescr_t descr
)

获取矩阵描述符的矩阵填充模式。

参数：

descr 矩阵描述符。

返回值：MUSPARSE_FILL_MODE_LOWER 或 MUSPARSE_FILL_MODE_UPPER。

musparseGetMatFillMode 返回矩阵描述符的矩阵填充模式。

函数 musparseGetMatIndexBase

musparseIndexBase_t musparseGetMatIndexBase(
    const musparseMatDescr_t descr
)

获取矩阵描述符的索引基。

参数：

descr 矩阵描述符。

返回值：MUSPARSE_INDEX_BASE_ZERO 或 MUSPARSE_INDEX_BASE_ONE。

musparseGetMatIndexBase 返回矩阵描述符的索引基。

函数 musparseGetMatType

musparseMatrixType_t musparseGetMatType(
    const musparseMatDescr_t descr
)

获取矩阵描述符的矩阵类型。

参数：

descr 矩阵描述符。

返回值：MUSPARSE_MATRIX_TYPE_GENERAL, MUSPARSE_MATRIX_TYPE_SYMMETRIC, MUSPARSE_MATRIX_TYPE_HERMITIAN 或 MUSPARSE_MATRIX_TYPE_TRIANGULAR。

musparseGetMatType 返回矩阵描述符的矩阵类型。

函数 musparseXbsrmm

MUSPARSE_EXPORT musparseStatus_t musparseXbsrmm()

使用 BSR 存储格式进行稀疏矩阵和密集矩阵相乘。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 块的存储格式。可以是 MUSPARSE_DIRECTION_ROW 或 MUSPARSE_DIRECTION_COLUMN。
trans_A 矩阵 $A$ 操作类型。目前仅支持 MUSPARSE_OPERATION_NON_TRANSPOSE。
trans_B 矩阵 $B$ 操作类型。目前仅支持 MUSPARSE_OPERATION_NON_TRANSPOSE 和 MUSPARSE_OPERATION_TRANSPOSE。
mb 稀疏 BSR 矩阵 $A$ 的块行数。
n 密集矩阵 $op(B)$ 和 $C$ 的列数。
kb 稀疏 BSR 矩阵 $A$ 的块列数。
nnzb 稀疏 BSR 矩阵 $A$ 的非零块数。
alpha 标量 $\alpha$ 。
descr 稀疏 BSR 矩阵 $A$ 的描述符。目前仅支持 MUSPARSE_MATRIX_TYPE_GENERAL。
bsr_val 长度为 nnzb*block_dim*block_dim 的数组，包含稀疏 BSR 矩阵 $A$ 的元素。
bsr_row_ptr 长度为 mb+1 的数组，指向稀疏 BSR 矩阵 $A$ 每个块行的起始位置。
bsr_col_ind 长度为 nnzb 的数组，包含稀疏 BSR 矩阵 $A$ 的块列索引。
block_dim 稀疏 BSR 矩阵中的块大小。
B 维度为 $ldb \times n$ ( $op(B) == B$ ) 的数组，否则为 $ldb \times k$ 。
ldb $B$ 的领先维度，必须至少为 $\max{(1,k)}$ ( $op(B) == B$ ) 其中 $k = block_dim \times kb$ ，否则为 $\max{(1,n)}$ 。
beta 标量 $\beta$ 。
C 维度为 $ldc \times n$ 的数组。
ldc $C$ 的领先维度，必须至少为 $\max{(1,m)}$ ( $op(A) == A$ ) 其中 $m = block_dim \times mb$ ，否则为 $\max{(1,k)}$ 其中 $k = block_dim \times kb$ 。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, n, kb, nnzb, ldb 或 ldc 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, alpha, bsr_val, bsr_row_ptr, bsr_col_ind, B, beta 或 C 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_ARCH_MISMATCH 设备不支持。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans_A != MUSPARSE_OPERATION_NON_TRANSPOSE 或 trans_B == MUSPARSE_OPERATION_CONJUGATE_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。
目前，仅支持 trans_A == MUSPARSE_OPERATION_NON_TRANSPOSE。

示例：

这个示例将 BSR 矩阵与密集矩阵相乘。

     //     1 2 0 3 0 0
     // A = 0 4 5 0 0 0
     //     0 0 0 7 8 0
     //     0 0 1 2 4 1
    
     muInt block_dim = 2;
     muInt mb   = 2;
     muInt kb   = 3;
     muInt nnzb = 4;
     musparseDirection_t dir = MUSPARSE_DIRECTION_ROW;
    
     bsr_row_ptr[mb+1]                 = {0, 2, 4}; // 设备内存
     bsr_col_ind[nnzb]                 = {0, 1, 1, 2}; // 设备内存
     bsr_val[nnzb*block_dim*block_dim] = {1, 2, 0, 4, 0, 3, 5, 0, 0, 7, 1, 2,
8, 0, 4, 1}; // 设备内存

     // 设置 B 的维度 n
     muInt n = 64;
     muInt m = mb * block_dim;
     muInt k = kb * block_dim;
    
     // 分配并生成密集矩阵 `B`
     std::vector<float> hB(k * n);
     for(muInt i = 0; i < k * n; ++i)
     {
         hB[i] = static_cast<float>(rand()) / RAND_MAX;
     }
    
     // 将 B 复制到设备
     float* B;
     musaMalloc((void**)&B, sizeof(float) * k * n);
     musaMemcpy(B, hB.data(), sizeof(float) * k * n, musaMemcpyHostToDevice);
    
     // alpha 和 beta
     float alpha = 1.0f;
     float beta  = 0.0f;
    
     // 为结果矩阵 C 分配内存
     float* C;
     musaMalloc((void**)&C, sizeof(float) * m * n);
    
     // 执行矩阵乘法
     musparseSbsrmm(handle,
                      dir,
                      MUSPARSE_OPERATION_NON_TRANSPOSE,
                      MUSPARSE_OPERATION_NON_TRANSPOSE,
                      mb,
                      n,
                      kb,
                      nnzb,
                      &alpha,
                      descr,
                      bsr_val,
                      bsr_row_ptr,
                      bsr_col_ind,
                      block_dim,
                      B,
                      k,
                      &beta,
                      C,
                      m);

musparseXbsrmm 将标量 $\alpha$ 与稀疏 $mb \times kb$ 矩阵 $A$ 相乘，定义在 BSR 存储格式中，与密集 $k \times n$ 矩阵 $B$ (其中 $k = block_dim \times kb$ ) 相乘，并将结果加到乘以标量 $\beta$ 的密集 $m \times n$ 矩阵 $C$ (其中 $m = block_dim \times mb$ ) 上，使得 $C := \alpha \cdot op(A) \cdot op(B) + \beta \cdot C,$ 其中

op(A) = \begin{cases} A, & \text{if trans\_A == MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \end{cases}

和

op(B) = \begin{cases} B, & \text{if trans\_B == MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \\ B^T, & \text{if trans\_B == MUSPARSE\_OPERATION\_TRANSPOSE} \end{cases}

 MUSPARSE_EXPORT
musparseStatus_t musparseSbsrmm(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_B, muInt mb, muInt n,
    muInt kb, muInt nnzb, const float* alpha, const musparseMatDescr_t descr,
    const float* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, const float* B, muInt ldb, const float* beta, float* C,
    muInt ldc);

MUSPARSE_EXPORT
musparseStatus_t musparseDbsrmm(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_B, muInt mb, muInt n,
    muInt kb, muInt nnzb, const double* alpha, const musparseMatDescr_t descr,
    const double* bsr_val, const muInt* bsr_row_ptr, const muInt* bsr_col_ind,
    muInt block_dim, const double* B, muInt ldb, const double* beta, double* C,
    muInt ldc);

MUSPARSE_EXPORT
musparseStatus_t musparseCbsrmm(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_B, muInt mb, muInt n,
    muInt kb, muInt nnzb, const muComplex* alpha,
    const musparseMatDescr_t descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    const muComplex* B, muInt ldb, const muComplex* beta, muComplex* C,
    muInt ldc);

MUSPARSE_EXPORT
musparseStatus_t musparseZbsrmm(
    musparseHandle_t handle, musparseDirection_t dir,
    musparseOperation_t trans_A, musparseOperation_t trans_B, muInt mb, muInt n,
    muInt kb, muInt nnzb, const muDoubleComplex* alpha,
    const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    const muDoubleComplex* B, muInt ldb, const muDoubleComplex* beta,
    muDoubleComplex* C, muInt ldc);

函数 musparseXcsric0_bufferSize

MUSPARSE_EXPORT musparseStatus_t musparseXcsric0_bufferSize()

使用 CSR 存储格式进行不完全 Cholesky 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
m 稀疏 CSR 矩阵的行数。
nnz 稀疏 CSR 矩阵的非零条目数。
descr 稀疏 CSR 矩阵的描述符。
csr_val 长度为 nnz 的数组，包含稀疏 CSR 矩阵的元素。
csr_row_ptr 长度为 m+1 的数组，指向稀疏 CSR 矩阵每一行的起始位置。
csr_col_ind 长度为 nnz 的数组，包含稀疏 CSR 矩阵的列索引。
info 结构体，存储分析步骤中收集的信息。
buffer_size musparseScsric0_analysis(), musparseDcsric0_analysis(), musparseScsric0() 和 musparseDcsric0() 所需的临时存储缓冲区的字节数。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE m 或 nnz 无效。
MUSPARSE_STATUS_INVALID_POINTER
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans != MUSPARSE_OPERATION_NON_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

musparseXcsric0_bufferSize 返回 musparseScsric0_analysis(), musparseDcsric0_analysis(), musparseScsric0() 和 musparseDcsric0() 所需的临时存储缓冲区的大小。临时存储缓冲区必须由用户分配。临时存储缓冲区的大小与 musparseScsrsv_bufferSize(), musparseDcsrsv_bufferSize(), musparseScsrilu0_bufferSize() 和 musparseDcsrilu0_bufferSize() 返回的大小相同，如果矩阵的稀疏模式相同。因此，用户分配的缓冲区可以在后续对这些函数的调用之间共享。

MUSPARSE_EXPORT
musparseStatus_t musparseScsric0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const float* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsric0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const double* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsric0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsric0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muDoubleComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info, size_t* buffer_size);

函数 musparseXcsric0_analysis

MUSPARSE_EXPORT musparseStatus_t musparseXcsric0_analysis()

使用 CSR 存储格式进行不完全 Cholesky 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
m 稀疏 CSR 矩阵的行数。
nnz 稀疏 CSR 矩阵的非零条目数。
descr 稀疏 CSR 矩阵的描述符。
csr_val 长度为 nnz 的数组，包含稀疏 CSR 矩阵的元素。
csr_row_ptr 长度为 m+1 的数组，指向稀疏 CSR 矩阵每一行的起始位置。
csr_col_ind 长度为 nnz 的数组，包含稀疏 CSR 矩阵的列索引。
info 结构体，存储分析步骤中收集的信息。
analysis MUSPARSE_ANALYSIS_POLICY_REUSE 或 MUSPARSE_ANALYSIS_POLICY_FORCE。
solve MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE m 或 nnz 无效。
MUSPARSE_STATUS_INVALID_POINTER
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans != MUSPARSE_OPERATION_NON_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

如果矩阵的稀疏模式发生变化，收集的信息将变得无效。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseXcsric0_analysis 执行 musparseScsric0() 和 musparseDcsric0() 的分析步骤。预计此函数将仅对给定矩阵和特定操作类型执行一次。分析元数据可以通过 musparseXcsric0_clear() 清除。

musparseXcsric0_analysis 可以与 musparseScsrilu0_analysis(), musparseDcsrilu0_analysis(), musparseCcsrilu0_analysis(), musparseZcsrilu0_analysis(), musparseScsrsv_analysis(), musparseDcsrsv_analysis(), musparseCcsrsv_analysis(), musparseZcsrsv_analysis(), musparseScsrsm_analysis(), musparseDcsrsm_analysis(), musparseScsrsm_analysis() 和 musparseDcsrsm_analysis() 共享其元数据。选择 MUSPARSE_ANALYSIS_POLICY_REUSE 策略可以大大提高元数据的计算性能。但是，用户需要确保稀疏模式保持不变。如果不能保证，必须使用 MUSPARSE_ANALYSIS_POLICY_FORCE。

 MUSPARSE_EXPORT
musparseStatus_t musparseScsric0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const float* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsric0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const double* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsric0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsric0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muDoubleComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);

函数 musparseXcsric0

MUSPARSE_EXPORT musparseStatus_t musparseXcsric0()

使用 CSR 存储格式进行不完全 Cholesky 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
m 稀疏 CSR 矩阵的行数。
nnz 稀疏 CSR 矩阵的非零条目数。
descr 稀疏 CSR 矩阵的描述符。
csr_val 长度为 nnz 的数组，包含稀疏 CSR 矩阵的元素。
csr_row_ptr 长度为 m+1 的数组，指向稀疏 CSR 矩阵每一行的起始位置。
csr_col_ind 长度为 nnz 的数组，包含稀疏 CSR 矩阵的列索引。
info 结构体，存储分析步骤中收集的信息。
policy MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE m 或 nnz 无效。
MUSPARSE_STATUS_INVALID_POINTER
MUSPARSE_EXPORT MUSPARSE_STATUS_ARCH_MISMATCH 设备不支持。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans != MUSPARSE_OPERATION_NON_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

稀疏 CSR 矩阵必须是排序的。可以通过调用 musparseXcsrsort() 来实现。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

 MUSPARSE_EXPORT
musparseStatus_t musparseScsric0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    float* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsric0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    double* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsric0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    muComplex* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsric0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    muDoubleComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info,
    musparseSolvePolicy_t policy, void* temp_buffer);

示例：

考虑存储在 CSR 存储格式中的稀疏 $m \times m$ 矩阵 $A$ 。以下示例计算不完全 Cholesky 分解 $M \approx LL^T$ 并求解预条件系统 $My = x$ 。

     // 创建 musparse 句柄
     musparseHandle_t handle;
     musparseCreate(&handle);
   
     // 为 M 创建矩阵描述符
     musparseMatDescr_t descr_M;
     musparseCreateMatDescr(&descr_M);
   
     // 为 L 创建矩阵描述符
     musparseMatDescr_t descr_L;
     musparseCreateMatDescr(&descr_L);
     musparseSetMatFillMode(descr_L, MUSPARSE_FILL_MODE_LOWER);
     musparseSetMatDiagType(descr_L, MUSPARSE_DIAG_TYPE_UNIT);
   
     // 为 L' 创建矩阵描述符
     musparseMatDescr_t descr_Lt;
     musparseCreateMatDescr(&descr_Lt);
     musparseSetMatFillMode(descr_Lt, MUSPARSE_FILL_MODE_UPPER);
     musparseSetMatDiagType(descr_Lt, MUSPARSE_DIAG_TYPE_NON_UNIT);
   
     // 创建矩阵信息结构
     musparseMatInfo_t info;
     musparseCreateMatInfo(&info);
   
     // 获取所需的缓冲区大小
     size_t buffer_size_M;
     size_t buffer_size_L;
     size_t buffer_size_Lt;
     musparseDcsric0_bufferSize(handle,
                                   m,
                                   nnz,
                                   descr_M,
                                   csr_val,
                                   csr_row_ptr,
                                   csr_col_ind,
                                   info,
                                   &buffer_size_M);
     musparseDcsrsv_bufferSize(handle,
                                  MUSPARSE_OPERATION_NON_TRANSPOSE,
                                  m,
                                  nnz,
                                  descr_L,
                                  csr_val,
                                  csr_row_ptr,
                                  csr_col_ind,
                                  info,
                                  &buffer_size_L);
     musparseDcsrsv_bufferSize(handle,
                                  MUSPARSE_OPERATION_TRANSPOSE,
                                  m,
                                  nnz,
                                  descr_Lt,
                                  csr_val,
                                  csr_row_ptr,
                                  csr_col_ind,
                                  info,
                                  &buffer_size_Lt);
   
     size_t buffer_size = max(buffer_size_M, max(buffer_size_L,
buffer_size_Lt));

     // 分配临时缓冲区
     void* temp_buffer;
     musaMalloc(&temp_buffer, buffer_size);
   
     // 执行分析步骤，使用 MUSPARSE_ANALYSIS_POLICY_REUSE 来
提高
     // 计算性能
     musparseDcsric0_analysis(handle,
                                m,
                                nnz,
                                descr_M,
                                csr_val,
                                csr_row_ptr,
                                csr_col_ind,
                                info,
                                MUSPARSE_ANALYSIS_POLICY_REUSE,
                                MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                                temp_buffer);
     musparseDcsrsv_analysis(handle,
                               MUSPARSE_OPERATION_NON_TRANSPOSE,
                               m,
                               nnz,
                               descr_L,
                               csr_val,
                               csr_row_ptr,
                               csr_col_ind,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);
     musparseDcsrsv_analysis(handle,
                               MUSPARSE_OPERATION_TRANSPOSE,
                               m,
                               nnz,
                               descr_Lt,
                               csr_val,
                               csr_row_ptr,
                               csr_col_ind,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);

     // 检查零主元
     muInt position;
     if(MUSPARSE_EXPORT
MUSPARSE_STATUS_ZERO_PIVOT == musparseXcsric0_zeroPivot(handle,
                                                                   info,
&position))
     {
         printf("A 在 A(%d,%d) 处有结构零\n", position, position);
     }

     // 计算不完全 Cholesky 分解 M = LL'
     musparseDcsric0(handle,
                       m,
                       nnz,
                       descr_M,
                       csr_val,
                       csr_row_ptr,
                       csr_col_ind,
                       info,
                       MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                       temp_buffer);
   
     // 检查零主元
     if(MUSPARSE_EXPORT
MUSPARSE_STATUS_ZERO_PIVOT == musparseXcsric0_zeroPivot(handle,
                                                                   info,
&position))
     {
         printf("L 在 L(%d,%d) 处有结构和/或数值零\n",
                position,
                position);
     }

     // 解 Lz = x
     musparseDcsrsv_solve(handle,
                            MUSPARSE_OPERATION_NON_TRANSPOSE,
                            m,
                            nnz,
                            &alpha,
                            descr_L,
                            csr_val,
                            csr_row_ptr,
                            csr_col_ind,
                            info,
                            x,
                            z,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 解 L'y = z
     musparseDcsrsv_solve(handle,
                            MUSPARSE_OPERATION_TRANSPOSE,
                            m,
                            nnz,
                            &alpha,
                            descr_Lt,
                            csr_val,
                            csr_row_ptr,
                            csr_col_ind,
                            info,
                            z,
                            y,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 清理
     musaFree(temp_buffer);
     musparseDestroyMatInfo(info);
     musparseDestroyMatDescr(descr_M);
     musparseDestroyMatDescr(descr_L);
     musparseDestroyMatDescr(descr_Lt);
     musparseDestroy(handle);

musparseXcsric0 计算稀疏 $m \times m$ CSR 矩阵 $A$ 的不完全 Cholesky 分解，不进行填零和不进行主元选取，使得 $A \approx LL^T$

musparseXcsric0 需要用户分配的临时缓冲区。其大小由 musparseScsric0_bufferSize() 或 musparseDcsric0_bufferSize() 返回。此外，需要分析元数据。可以通过 musparseScsric0_analysis() 或 musparseDcsric0_analysis() 获取。musparseXcsric0 报告第一个零主元（无论是数值零还是结构零）。零主元状态可以通过调用 musparseXcsric0_zeroPivot() 获取。

函数 musparseXcsric0_zeroPivot

MUSPARSE_EXPORT musparseStatus_t musparseXcsric0_zeroPivot(
    musparseHandle_t handle,
    musparseMatInfo_t info,
    muInt * position
)

使用 CSR 存储格式进行不完全 Cholesky 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
info 结构体，存储分析步骤中收集的信息。
position 指向零主元 $j$ 的指针，可以位于主机或设备内存中。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info 或 position 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT 发现零主元。

注意：musparseXcsric0_zeroPivot 是一个阻塞函数。它可能会对性能产生负面影响。

musparse_csric_zero_pivot 返回 MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT，如果在 musparseScsric0() 或 musparseDcsric0() 计算期间发现结构零或数值零。第一个零主元 $j$ 在 $A_{j,j}$ 处存储在 position 中，使用与 CSR 矩阵相同的索引基。

position 可以位于主机或设备内存中。如果没有发现零主元，position 设置为 -1，并且返回MUSPARSE_STATUS_SUCCESS。

函数 musparseXbsric0_bufferSize

MUSPARSE_EXPORT musparseStatus_t musparseXbsric0_bufferSize()

使用 BSR 存储格式进行不完全 Cholesky 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 方向，指定是按 MUSPARSE_DIRECTION_ROW 还是按 MUSPARSE_DIRECTION_COLUMN 计数非零元素。
mb 稀疏 BSR 矩阵的块行数。
nnzb 稀疏 BSR 矩阵的非零块条目数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 长度为 nnzb*block_dim*block_dim 的数组，包含稀疏 BSR 矩阵的值。
bsr_row_ptr 长度为 mb+1 的数组，指向稀疏 BSR 矩阵每个块行的起始位置。
bsr_col_ind 长度为 nnzb 的数组，包含稀疏 BSR 矩阵的块列索引。
block_dim BSR 矩阵的块维度。在 1 和 m 之间，其中 m=mb*block_dim。
info 结构体，存储分析步骤中收集的信息。
buffer_size musparseSbsric0_analysis(), musparseDbsric0_analysis(), musparseCbsric0_analysis(), musparseZbsric0_analysis(), musparseSbsric0(), musparseDbsric0(), musparseCbsric0() 和 musparseZbsric0() 所需的临时存储缓冲区的字节数。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb, 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr, bsr_col_ind, info 或 buffer_size 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

musparseXbsric0_bufferSize 返回 musparseSbsric0_analysis(), musparseDbsric0_analysis(), musparseCbsric0_analysis(), musparseZbsric0_analysis(), musparseSbsric0(), musparseDbsric0(), musparseCbsric0() 和 musparseZbsric0() 所需的临时存储缓冲区的大小。临时存储缓冲区必须由用户分配。临时存储缓冲区的大小与 musparseSbsrsv_bufferSize(), musparseDbsrsv_bufferSize(), musparseCbsrsv_bufferSize(), musparseZbsrsv_bufferSize(), musparseSbsrilu0_bufferSize(), musparseDbsrilu0_bufferSize(), musparseCbsrilu0_bufferSize() 和 musparseZbsrilu0_bufferSize() 返回的大小相同，如果矩阵的稀疏模式相同。因此，用户分配的缓冲区可以在后续对这些函数的调用之间共享。

 MUSPARSE_EXPORT
musparseStatus_t musparseSbsric0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const float* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseDbsric0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const double* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseCbsric0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseZbsric0_bufferSize(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, size_t* buffer_size);

函数 musparseXbsric0_analysis

MUSPARSE_EXPORT musparseStatus_t musparseXbsric0_analysis()

使用 BSR 存储格式进行不完全 Cholesky 分解，不进行填零和不进行主元选取。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 方向，指定是按 MUSPARSE_DIRECTION_ROW 还是按 MUSPARSE_DIRECTION_COLUMN 计数非零元素。
mb 稀疏 BSR 矩阵的块行数。
nnzb 稀疏 BSR 矩阵的非零块条目数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 长度为 nnzb*block_dim*block_dim 的数组，包含稀疏 BSR 矩阵的值。
bsr_row_ptr 长度为 mb+1 的数组，指向稀疏 BSR 矩阵每个块行的起始位置。
bsr_col_ind 长度为 nnzb 的数组，包含稀疏 BSR 矩阵的块列索引。
block_dim BSR 矩阵的块维度。在 1 和 m 之间，其中 m=mb*block_dim。
info 结构体，存储分析步骤中收集的信息。
analysis MUSPARSE_ANALYSIS_POLICY_REUSE 或 MUSPARSE_ANALYSIS_POLICY_FORCE。
solve MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb, 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr, bsr_col_ind, info 或 temp_buffer 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 内部错误发生。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

如果矩阵的稀疏模式发生变化，收集的信息将变得无效。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseXbsric0_analysis 执行 musparseSbsric0(), musparseDbsric0(), musparseCbsric0() 和 musparseZbsric0() 的分析步骤。预计此函数将仅对给定矩阵和特定操作类型执行一次。分析元数据可以通过 musparseXbsric0_clear() 清除。

musparseXbsric0_analysis 可以与 musparseSbsrilu0_analysis(), musparseDbsrilu0_analysis(), musparseCbsrilu0_analysis(), musparseZbsrilu0_analysis(), musparseSbsrsv_analysis(), musparseDbsrsv_analysis(), musparseCbsrsv_analysis(), musparseZbsrsv_analysis(), musparseSbsrsm_analysis(), musparseDbsrsm_analysis(), musparseCbsrsm_analysis() 和 musparseZbsrsm_analysis() 共享其元数据。选择 MUSPARSE_ANALYSIS_POLICY_REUSE 策略可以大大提高元数据的计算性能。但是，用户需要确保稀疏模式保持不变。如果不能保证，必须使用 MUSPARSE_ANALYSIS_POLICY_FORCE。

 MUSPARSE_EXPORT
musparseStatus_t musparseSbsric0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const float* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseDbsric0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const double* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseCbsric0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseZbsric0_analysis(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

函数 musparseXbsric0

MUSPARSE_EXPORT musparseStatus_t musparseXbsric0()

使用 BSR 存储格式进行不完全 Cholesky 分解，填充数为 0，不进行主元变换。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 方向，指定是按 MUSPARSE_DIRECTION_ROW 还是按 MUSPARSE_DIRECTION_COLUMN 计数非零元素。
mb 稀疏 BSR 矩阵的块行数。
nnzb 稀疏 BSR 矩阵的非零块条目数。
descr 稀疏 BSR 矩阵的描述符。
bsr_val 长度为 nnzb*block_dim*block_dim 的数组，包含稀疏 BSR 矩阵的值。
bsr_row_ptr 长度为 mb+1 的数组，指向稀疏 BSR 矩阵每个块行的开始位置。
bsr_col_ind 长度为 nnzb 的数组，包含稀疏 BSR 矩阵的块列索引。
block_dim BSR 矩阵的块维度。在 1 和 m 之间，其中 m=mb*block_dim。
info 结构体，存储分析步骤中收集的信息。
policy MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nnzb, 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, bsr_val, bsr_row_ptr 或 bsr_col_ind 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_ARCH_MISMATCH 设备不受支持。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

示例：

考虑以 BSR 存储格式存储的稀疏 $m \times m$ 矩阵 $A$ 。以下示例计算不完全 Cholesky 分解 $M \approx LL^T$ 并求解预处理系统 $My = x$ 。

     // 创建 musparse 句柄
     musparseHandle_t handle;
     musparseCreate(&handle);
   
     // 为 M 创建矩阵描述符
     musparseMatDescr_t descr_M;
     musparseCreateMatDescr(&descr_M);
   
     // 为 L 创建矩阵描述符
     musparseMatDescr_t descr_L;
     musparseCreateMatDescr(&descr_L);
     musparseSetMatFillMode(descr_L, MUSPARSE_FILL_MODE_LOWER);
     musparseSetMatDiagType(descr_L, MUSPARSE_DIAG_TYPE_UNIT);
   
     // 为 L' 创建矩阵描述符
     musparseMatDescr_t descr_Lt;
     musparseCreateMatDescr(&descr_Lt);
     musparseSetMatFillMode(descr_Lt, MUSPARSE_FILL_MODE_UPPER);
     musparseSetMatDiagType(descr_Lt, MUSPARSE_DIAG_TYPE_NON_UNIT);
   
     // 创建矩阵信息结构
     musparseMatInfo_t info;
     musparseCreateMatInfo(&info);
   
     // 获取所需的缓冲区大小
     size_t buffer_size_M;
     size_t buffer_size_L;
     size_t buffer_size_Lt;
     musparseDbsric0_bufferSize(handle,
                                    MUSPARSE_DIRECTION_ROW,
                                    mb,
                                    nnzb,
                                    descr_M,
                                    bsr_val,
                                    bsr_row_ptr,
                                    bsr_col_ind,
                                    block_dim,
                                    info,
                                    &buffer_size_M);
     musparseDbsrsv_bufferSize(handle,
                                  MUSPARSE_DIRECTION_ROW,
                                  MUSPARSE_OPERATION_NON_TRANSPOSE,
                                  mb,
                                  nnzb,
                                  descr_L,
                                  bsr_val,
                                  bsr_row_ptr,
                                  bsr_col_ind,
                                  block_dim,
                                  info,
                                  &buffer_size_L);
     musparseDbsrsv_bufferSize(handle,
                                  MUSPARSE_DIRECTION_ROW,
                                  MUSPARSE_OPERATION_TRANSPOSE,
                                  mb,
                                  nnzb,
                                  descr_Lt,
                                  bsr_val,
                                  bsr_row_ptr,
                                  bsr_col_ind,
                                  block_dim,
                                  info,
                                  &buffer_size_Lt);
   
     size_t buffer_size = max(buffer_size_M, max(buffer_size_L,
buffer_size_Lt));

     // 分配临时缓冲区
     void* temp_buffer;
     musaMalloc(&temp_buffer, buffer_size);
   
     // 执行分析步骤，使用 MUSPARSE_ANALYSIS_POLICY_REUSE 来
提高
     // 计算性能
     musparseDbsric0_analysis(handle,
                                MUSPARSE_DIRECTION_ROW,
                                mb,
                                nnzb,
                                descr_M,
                                bsr_val,
                                bsr_row_ptr,
                                bsr_col_ind,
                                block_dim,
                                info,
                                MUSPARSE_ANALYSIS_POLICY_REUSE,
                                MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                                temp_buffer);
     musparseDbsrsv_analysis(handle,
                               MUSPARSE_DIRECTION_ROW,
                               MUSPARSE_OPERATION_NON_TRANSPOSE,
                               mb,
                               nnzb,
                               descr_L,
                               bsr_val,
                               bsr_row_ptr,
                               bsr_col_ind,
                               block_dim,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);
     musparseDbsrsv_analysis(handle,
                               MUSPARSE_DIRECTION_ROW,
                               MUSPARSE_OPERATION_TRANSPOSE,
                               mb,
                               nnzb,
                               descr_Lt,
                               bsr_val,
                               bsr_row_ptr,
                               bsr_col_ind,
                               block_dim,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);

     // 检查零主元
     muInt position;
     if(MUSPARSE_EXPORT
MUSPARSE_STATUS_ZERO_PIVOT == musparseXbsric0_zeroPivot(handle,
                                                                   info,
&position))
     {
         printf("A 在 A(%d,%d) 处有结构零\n", position, position);
     }

     // 计算不完全 Cholesky 分解 M = LL'
     musparseDbsric0(handle,
                        MUSPARSE_DIRECTION_ROW,
                        mb,
                        nnzb,
                        descr_M,
                        bsr_val,
                        bsr_row_ptr,
                        bsr_col_ind,
                        block_dim,
                        info,
                        MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                        temp_buffer);
   
     // 检查零主元
     if(MUSPARSE_EXPORT
MUSPARSE_STATUS_ZERO_PIVOT == musparseXbsric0_zeroPivot(handle,
                                                                    info,
&position))
     {
         printf("L 在 L(%d,%d) 处有结构和/或数值零\n",
                position,
                position);
     }

     // 解决 Lz = x
     musparseDbsrsv_solve(handle,
                            MUSPARSE_DIRECTION_ROW,
                            MUSPARSE_OPERATION_NON_TRANSPOSE,
                            mb,
                            nnzb,
                            &alpha,
                            descr_L,
                            bsr_val,
                            bsr_row_ptr,
                            bsr_col_ind,
                            block_dim,
                            info,
                            x,
                            z,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 解决 L'y = z
     musparseDbsrsv_solve(handle,
                            MUSPARSE_DIRECTION_ROW,
                            MUSPARSE_OPERATION_TRANSPOSE,
                            mb,
                            nnzb,
                            &alpha,
                            descr_Lt,
                            bsr_val,
                            bsr_row_ptr,
                            bsr_col_ind,
                            block_dim,
                            info,
                            z,
                            y,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 清理
     musaFree(temp_buffer);
     musparseDestroyMatInfo(info);
     musparseDestroyMatDescr(descr_M);
     musparseDestroyMatDescr(descr_L);
     musparseDestroyMatDescr(descr_Lt);
     musparseDestroy(handle);

musparseXbsric0 计算稀疏 $mb \times mb$ BSR 矩阵 $A$ 的不完全 Cholesky 分解，填充数为 0，不进行主元变换，使得 $A \approx LL^T$

musparseXbsric0 需要用户分配的临时缓冲区。其大小由 musparseSbsric0_bufferSize(), musparseDbsric0_bufferSize(), musparseCbsric0_bufferSize() 或 musparseZbsric0_bufferSize() 返回。此外，需要分析元数据。可以通过 musparseSbsric0_analysis(), musparseDbsric0_analysis(), musparseCbsric0_analysis() 或 musparseZbsric0_analysis() 获取。musparseXbsric0 报告第一个零主元（无论是数值零还是结构零）。零主元状态可以通过调用 musparseXbsric0_zeroPivot()获取。

MUSPARSE_EXPORT
musparseStatus_t musparseSbsric0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, float* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseDbsric0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, double* bsr_val, const muInt* bsr_row_ptr,
    const muInt* bsr_col_ind, muInt block_dim, musparseMatInfo_t info,
    musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseCbsric0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseZbsric0(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nnzb,
    const musparseMatDescr_t descr, muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

函数 musparseXbsric0_zeroPivot

MUSPARSE_EXPORT musparseStatus_t musparseXbsric0_zeroPivot(
    musparseHandle_t handle,
    musparseMatInfo_t info,
    muInt * position
)

使用 BSR 存储格式进行不完全 Cholesky 分解，填充数为 0，不进行主元变换。

参数：

handle muSPARSE 库上下文队列的句柄。
info 结构体，存储分析步骤中收集的信息。
position 指向零主元 $j$ 的指针，可以位于主机或设备内存中。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info 或 position 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT 找到零主元。

注意：

如果找到零主元，position=j 表示对角块 A(j,j) 缺失（结构零）或对角块 A(j,j) 不是正定的（数值零）。
musparseXbsric0_zeroPivot 是一个阻塞函数。它可能会对性能产生负面影响。

musparseXbsric0_zeroPivot 返回 MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT，如果在 musparseSbsric0(), musparseDbsric0(), musparseCbsric0() 或 musparseZbsric0() 计算期间发现结构零或数值零。第一个零主元 $j$ 在 $A_{j,j}$ 处存储在 position 中，使用与 BSR 矩阵相同的索引基。

position 可以位于主机或设备内存中。如果没有发现零主元，position 设置为 -1，并且返回MUSPARSE_STATUS_SUCCESS。

函数 musparseXcsrilu0_numericBoost

MUSPARSE_EXPORT musparseStatus_t musparseXcsrilu0_numericBoost()

使用 CSR 存储格式进行不完全 LU 分解，填充数为 0，不进行主元变换。

参数：

handle muSPARSE 库上下文队列的句柄。
info 结构体，存储分析步骤中收集的信息。
enable_boost 启用/禁用数值增强。
boost_tol 确定是否替换数值的容忍度。
boost_val 替换数值的增强值。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info, tol 或 boost_val 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。

注意：

通过将 enable_boost 设置为 1 来启用增强值，通过将 enable_boost 设置为 0 来禁用增强值。
tol 和 boost_val 可以位于主机或设备内存中。

MUSPARSE_EXPORT
musparseStatus_t musparseScsrilu0_numericBoost(musparseHandle_t handle,
                                               musparseMatInfo_t info,
                                               int enable_boost,
                                               const float* boost_tol,
                                               const float* boost_val);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsrilu0_numericBoost(musparseHandle_t handle,
                                               musparseMatInfo_t info,
                                               int enable_boost,
                                               const double* boost_tol,
                                               const double* boost_val);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsrilu0_numericBoost(musparseHandle_t handle,
                                               musparseMatInfo_t info,
                                               int enable_boost,
                                               const float* boost_tol,
                                               const muComplex* boost_val);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsrilu0_numericBoost(
    musparseHandle_t handle, musparseMatInfo_t info, int enable_boost,
    const double* boost_tol, const muDoubleComplex* boost_val);

MUSPARSE_EXPORT
musparseStatus_t musparseDScsrilu0_numericBoost(musparseHandle_t handle,
                                                musparseMatInfo_t info,
                                                int enable_boost,
                                                const double* boost_tol,
                                                const float* boost_val);

MUSPARSE_EXPORT
musparseStatus_t musparseDCcsrilu0_numericBoost(musparseHandle_t handle,
                                                musparseMatInfo_t info,
                                                int enable_boost,
                                                const double* boost_tol,
                                                const muComplex* boost_val);

musparseXcsrilu0_numericBoost 允许用户在不完全 LU 分解中替换数值。tol 用于确定是否用 boost_val 替换数值，使得 $A_{j,j} = \text{boost\_val}$ 如果 $\text{tol} \ge \left| A_{j,j} \right|$ .

函数 musparseXcsrilu0_bufferSize

MUSPARSE_EXPORT musparseStatus_t musparseXcsrilu0_bufferSize()

使用 CSR 存储格式进行不完全 LU 分解，填充数为 0，不进行主元变换。

参数：

handle muSPARSE 库上下文队列的句柄。
m 稀疏 CSR 矩阵的行数。
nnz 稀疏 CSR 矩阵的非零条目数。
descr 稀疏 CSR 矩阵的描述符。
csr_val 稀疏 CSR 矩阵的 nnz 个元素的数组。
csr_row_ptr 指向稀疏 CSR 矩阵每行开始位置的 m+1 个元素的数组。
csr_col_ind 包含稀疏 CSR 矩阵列索引的 nnz 个元素的数组。
info 结构体，存储分析步骤中收集的信息。
buffer_size musparseScsrilu0_analysis(), musparseDcsrilu0_analysis(), musparseCcsrilu0_analysis(), musparseZcsrilu0_analysis(), musparseScsrilu0(), musparseDcsrilu0(), musparseCcsrilu0() 和 musparseZcsrilu0() 所需的临时存储缓冲区的字节数。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE m 或 nnz 无效。
MUSPARSE_STATUS_INVALID_POINTER
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans != MUSPARSE_OPERATION_NON_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

musparseXcsrilu0_bufferSize 返回 musparseScsrilu0_analysis(), musparseDcsrilu0_analysis(), musparseCcsrilu0_analysis(), musparseZcsrilu0_analysis(), musparseScsrilu0(), musparseDcsrilu0(), musparseCcsrilu0() 和 musparseZcsrilu0() 所需的临时存储缓冲区的大小。用户必须分配临时存储缓冲区。临时存储缓冲区的大小与 musparseScsrsv_bufferSize(), musparseDcsrsv_bufferSize(), musparseCcsrsv_bufferSize() 和 musparseZcsrsv_bufferSize() 返回的大小相同，如果矩阵稀疏模式相同。因此，用户分配的缓冲区可以在后续对这些函数的调用之间共享。

MUSPARSE_EXPORT
musparseStatus_t musparseScsrilu0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const float* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsrilu0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const double* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsrilu0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info, size_t* buffer_size);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsrilu0_bufferSize(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muDoubleComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info, size_t* buffer_size);

descr, csr_val, csr_row_ptr, csr_col_ind, info 或 buffer_size 指针无效。

函数 musparseXcsrilu0_analysis

MUSPARSE_EXPORT musparseStatus_t musparseXcsrilu0_analysis()

使用 CSR 存储格式进行不完全 LU 分解，填充数为 0，不进行主元变换。

参数：

handle muSPARSE 库上下文队列的句柄。
m 稀疏 CSR 矩阵的行数。
nnz 稀疏 CSR 矩阵的非零条目数。
descr 稀疏 CSR 矩阵的描述符。
csr_val 稀疏 CSR 矩阵的 nnz 个元素的数组。
csr_row_ptr 指向稀疏 CSR 矩阵每行开始位置的 m+1 个元素的数组。
csr_col_ind 包含稀疏 CSR 矩阵列索引的 nnz 个元素的数组。
info 结构体，存储分析步骤中收集的信息。
analysis MUSPARSE_ANALYSIS_POLICY_REUSE 或 MUSPARSE_ANALYSIS_POLICY_FORCE。
solve MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE m 或 nnz 无效。
MUSPARSE_STATUS_INVALID_POINTER
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans != MUSPARSE_OPERATION_NON_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

如果矩阵稀疏模式发生变化，收集的信息将变得无效。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

MUSPARSE_EXPORT
musparseStatus_t musparseScsrilu0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const float* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsrilu0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const double* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseAnalysisPolicy_t analysis,
    musparseSolvePolicy_t solve, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsrilu0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsrilu0_analysis(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    const muDoubleComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info,
    musparseAnalysisPolicy_t analysis, musparseSolvePolicy_t solve,
    void* temp_buffer);

musparseXcsrilu0_analysis 执行 musparseScsrilu0(), musparseDcsrilu0(), musparseCcsrilu0() 和 musparseZcsrilu0() 的分析步骤。预计此函数仅对给定矩阵和特定操作类型执行一次。分析元数据可以通过 musparseXcsrilu0_clear() 清除。

musparseXcsrilu0_analysis 可以与 musparseScsric0_analysis(), musparseDcsric0_analysis(), musparseCcsric0_analysis(), musparseZcsric0_analysis(), musparseScsrsv_analysis(), musparseDcsrsv_analysis(), musparseCcsrsv_analysis(), musparseZcsrsv_analysis(), musparseScsrsm_analysis(), musparseDcsrsm_analysis(), musparseScsrsm_analysis() 和 musparseDcsrsm_analysis() 共享其元数据。选择 MUSPARSE_ANALYSIS_POLICY_REUSE 策略可以大大提高元数据的计算性能。但是，用户需要确保稀疏模式保持不变。如果不能保证，必须使用 MUSPARSE_ANALYSIS_POLICY_FORCE。

descr, csr_val, csr_row_ptr, csr_col_ind, info 或 temp_buffer 指针无效。

函数 musparseXcsrilu0

MUSPARSE_EXPORT musparseStatus_t musparseXcsrilu0()

使用 CSR 存储格式进行不完全 LU 分解，填充数为 0，不进行主元变换。

参数：

handle muSPARSE 库上下文队列的句柄。
m 稀疏 CSR 矩阵的行数。
nnz 稀疏 CSR 矩阵的非零条目数。
descr 稀疏 CSR 矩阵的描述符。
csr_val 稀疏 CSR 矩阵的 nnz 个元素的数组。
csr_row_ptr 指向稀疏 CSR 矩阵每行开始位置的 m+1 个元素的数组。
csr_col_ind 包含稀疏 CSR 矩阵列索引的 nnz 个元素的数组。
info 结构体，存储分析步骤中收集的信息。
policy MUSPARSE_SOLVE_POLICY_USE_LEVEL。
temp_buffer 用户分配的临时存储缓冲区。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE m 或 nnz 无效。
MUSPARSE_STATUS_INVALID_POINTER
MUSPARSE_EXPORT MUSPARSE_STATUS_ARCH_MISMATCH 设备不受支持。 *
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。 * *
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans != MUSPARSE_OPERATION_NON_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

稀疏 CSR 矩阵必须是排序的。可以通过调用 musparseXcsrsort() 实现。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

MUSPARSE_EXPORT
musparseStatus_t musparseScsrilu0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    float* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsrilu0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    double* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsrilu0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    muComplex* csr_val, const muInt* csr_row_ptr, const muInt* csr_col_ind,
    musparseMatInfo_t info, musparseSolvePolicy_t policy, void* temp_buffer);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsrilu0(
    musparseHandle_t handle, muInt m, muInt nnz, const musparseMatDescr_t descr,
    muDoubleComplex* csr_val, const muInt* csr_row_ptr,
    const muInt* csr_col_ind, musparseMatInfo_t info,
    musparseSolvePolicy_t policy, void* temp_buffer);

示例：

考虑以 CSR 存储格式存储的稀疏 $m \times m$ 矩阵 $A$ 。以下示例计算不完全 LU 分解 $M \approx LU$ 并求解预处理系统 $My =x$ 。

     // 创建 musparse 句柄
     musparseHandle_t handle;
     musparseCreate(&handle);
   
     // 为 M 创建矩阵描述符
     musparseMatDescr_t descr_M;
     musparseCreateMatDescr(&descr_M);
   
     // 为 L 创建矩阵描述符
     musparseMatDescr_t descr_L;
     musparseCreateMatDescr(&descr_L);
     musparseSetMatFillMode(descr_L, MUSPARSE_FILL_MODE_LOWER);
     musparseSetMatDiagType(descr_L, MUSPARSE_DIAG_TYPE_UNIT);
   
     // 为 U 创建矩阵描述符
     musparseMatDescr_t descr_U;
     musparseCreateMatDescr(&descr_U);
     musparseSetMatFillMode(descr_U, MUSPARSE_FILL_MODE_UPPER);
     musparseSetMatDiagType(descr_U, MUSPARSE_DIAG_TYPE_NON_UNIT);
   
     // 创建矩阵信息结构
     musparseMatInfo_t info;
     musparseCreateMatInfo(&info);
   
     // 获取所需的缓冲区大小
     size_t buffer_size_M;
     size_t buffer_size_L;
     size_t buffer_size_U;
     musparseDcsrilu0_bufferSize(handle,
                                   m,
                                   nnz,
                                   descr_M,
                                   csr_val,
                                   csr_row_ptr,
                                   csr_col_ind,
                                   info,
                                   &buffer_size_M);
     musparseDcsrsv_bufferSize(handle,
                                  MUSPARSE_OPERATION_NON_TRANSPOSE,
                                  m,
                                  nnz,
                                  descr_L,
                                  csr_val,
                                  csr_row_ptr,
                                  csr_col_ind,
                                  info,
                                  &buffer_size_L);
     musparseDcsrsv_bufferSize(handle,
                                  MUSPARSE_OPERATION_NON_TRANSPOSE,
                                  m,
                                  nnz,
                                  descr_U,
                                  csr_val,
                                  csr_row_ptr,
                                  csr_col_ind,
                                  info,
                                  &buffer_size_U);
   
     size_t buffer_size = max(buffer_size_M, max(buffer_size_L,
buffer_size_U));

     // 分配临时缓冲区
     void* temp_buffer;
     musaMalloc(&temp_buffer, buffer_size);
   
     // 执行分析步骤，使用 MUSPARSE_ANALYSIS_POLICY_REUSE 来
提高
     // 计算性能
     musparseDcsrilu0_analysis(handle,
                                 m,
                                 nnz,
                                 descr_M,
                                 csr_val,
                                 csr_row_ptr,
                                 csr_col_ind,
                                 info,
                                 MUSPARSE_ANALYSIS_POLICY_REUSE,
                                 MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                                 temp_buffer);
     musparseDcsrsv_analysis(handle,
                               MUSPARSE_OPERATION_NON_TRANSPOSE,
                               m,
                               nnz,
                               descr_L,
                               csr_val,
                               csr_row_ptr,
                               csr_col_ind,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);
     musparseDcsrsv_analysis(handle,
                               MUSPARSE_OPERATION_NON_TRANSPOSE,
                               m,
                               nnz,
                               descr_U,
                               csr_val,
                               csr_row_ptr,
                               csr_col_ind,
                               info,
                               MUSPARSE_ANALYSIS_POLICY_REUSE,
                               MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                               temp_buffer);

     // 检查零主元
     muInt position;
     if(MUSPARSE_EXPORT
MUSPARSE_STATUS_ZERO_PIVOT == musparseXcsrilu0_zeroPivot(handle,
                                                                    info,
&position))
     {
         printf("A 在 A(%d,%d) 处有结构零\n", position, position);
     }

     // 计算不完全 LU 分解
     musparseDcsrilu0(handle,
                        m,
                        nnz,
                        descr_M,
                        csr_val,
                        csr_row_ptr,
                        csr_col_ind,
                        info,
                        MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                        temp_buffer);
   
     // 检查零主元
     if(MUSPARSE_EXPORT
MUSPARSE_STATUS_ZERO_PIVOT == musparseXcsrilu0_zeroPivot(handle,
                                                                    info,
&position))
     {
         printf("U 在 U(%d,%d) 处有结构和/或数值零\n",
                position,
                position);
     }

     // 解决 Lz = x
     musparseDcsrsv_solve(handle,
                            MUSPARSE_OPERATION_NON_TRANSPOSE,
                            m,
                            nnz,
                            &alpha,
                            descr_L,
                            csr_val,
                            csr_row_ptr,
                            csr_col_ind,
                            info,
                            x,
                            z,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 解决 Uy = z
     musparseDcsrsv_solve(handle,
                            MUSPARSE_OPERATION_NON_TRANSPOSE,
                            m,
                            nnz,
                            &alpha,
                            descr_U,
                            csr_val,
                            csr_row_ptr,
                            csr_col_ind,
                            info,
                            z,
                            y,
                            MUSPARSE_SOLVE_POLICY_USE_LEVEL,
                            temp_buffer);
   
     // 清理
     musaFree(temp_buffer);
     musparseDestroyMatInfo(info);
     musparseDestroyMatDescr(descr_M);
     musparseDestroyMatDescr(descr_L);
     musparseDestroyMatDescr(descr_U);
     musparseDestroy(handle);

musparseXcsrilu0 计算稀疏 $m \times m$ CSR 矩阵 $A$ 的不完全 LU 分解，填充数为 0，不进行主元变换，使得 $A \approx LU$

musparseXcsrilu0 需要用户分配的临时缓冲区。其大小由 musparseScsrilu0_bufferSize(), musparseDcsrilu0_bufferSize(), musparseCcsrilu0_bufferSize() 或 musparseZcsrilu0_bufferSize() 返回。此外，需要分析元数据。可以通过 musparseScsrilu0_analysis(), musparseDcsrilu0_analysis(), musparseCcsrilu0_analysis() 或 musparseZcsrilu0_analysis() 获取。musparseXcsrilu0 报告第一个零主元（无论是数值零还是结构零）。零主元状态可以通过调用 musparseXcsrilu0_zeroPivot() 获取。

descr, csr_val, csr_row_ptr 或 csr_col_ind 指针无效。

函数 musparseXcsrilu0_zeroPivot

MUSPARSE_EXPORT musparseStatus_t musparseXcsrilu0_zeroPivot(
    musparseHandle_t handle,
    musparseMatInfo_t info,
    muInt * position
)

使用 CSR 存储格式进行不完全 LU 分解，填充数为 0，不进行主元变换。

参数：

handle muSPARSE 库上下文队列的句柄。
info 结构体，存储分析步骤中收集的信息。
position 指向零主元 $j$ 的指针，可以位于主机或设备内存中。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER info 或 position 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_INTERNAL_ERROR 发生内部错误。
MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT 找到零主元。

注意：musparseXcsrilu0_zeroPivot 是一个阻塞函数。它可能会对性能产生负面影响。

musparseXcsrilu0_zeroPivot 返回 MUSPARSE_EXPORT MUSPARSE_STATUS_ZERO_PIVOT，如果在 musparseScsrilu0(), musparseDcsrilu0(), musparseCcsrilu0() 或 musparseZcsrilu0() 计算期间发现结构零或数值零。第一个零主元 $j$ 在 $A_{j,j}$ 处存储在 position 中，使用与 CSR 矩阵相同的索引基。

position 可以位于主机或设备内存中。如果没有发现零主元，position 设置为 -1，并且返回MUSPARSE_STATUS_SUCCESS。

函数 musparseCreateCsr

MUSPARSE_EXPORT musparseStatus_t musparseCreateCsr(
    musparseSpMatDescr_t * descr,
    int64_t rows,
    int64_t cols,
    int64_t nnz,
    void * csr_row_ptr,
    void * csr_col_ind,
    void * csr_val,
    musparseIndexType_t row_ptr_type,
    musparseIndexType_t col_ind_type,
    musparseIndexBase_t idx_base,
    musparseDataType_t data_type
)

创建稀疏 CSR 矩阵描述符。

参数：

descr 指向稀疏 CSR 矩阵描述符的指针。
rows CSR 矩阵的行数。
cols CSR 矩阵的列数
nnz CSR 矩阵的非零数。
csr_row_ptr CSR 矩阵的行偏移量（必须是长度为 rows+1 的数组）。
csr_col_ind CSR 矩阵的列索引（必须是长度为 nnz 的数组）。
csr_val CSR 矩阵的值（必须是长度为 nnz 的数组）。
row_ptr_type MUSPARSE_INDEX_32I 或 MUSPARSE_INDEX_64I。
col_ind_type MUSPARSE_INDEX_32I 或 MUSPARSE_INDEX_64I。
idx_base MUSPARSE_INDEX_BASE_ZERO 或 MUSPARSE_INDEX_BASE_ONE。
data_type MUSA_R_32F, MUSA_R_64F, MUSA_C_32F 或 MUSA_C_64F。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER 如果 descr 或 csr_row_ptr 或 csr_col_ind 或 csr_val 无效。
MUSPARSE_STATUS_INVALID_SIZE 如果 rows 或 cols 或 nnz 无效。
MUSPARSE_STATUS_INVALID_VALUE 如果 row_ptr_type 或 col_ind_type 或 idx_base 或 data_type 无效。

musparseCreateCsr 创建稀疏 CSR 矩阵描述符。最后应使用 musparseDestroySpMat 销毁。

函数 musparseCreateDnVec

MUSPARSE_EXPORT musparseStatus_t musparseCreateDnVec(
    musparseDnVecDescr_t * descr,
    int64_t size,
    void * values,
    musparseDataType_t data_type
)

创建密集向量描述符。

参数：

descr 指向密集向量描述符的指针。
size 密集向量的大小。
values 密集向量的非零值（必须是长度为 size 的数组）。
data_type MUSA_R_32F, MUSA_R_64F, MUSA_C_32F 或 MUSA_C_64F。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER 如果 descr 或 values 无效。
MUSPARSE_STATUS_INVALID_SIZE 如果 size 无效。
MUSPARSE_STATUS_INVALID_VALUE 如果 data_type 无效。

musparseCreateDnVec 创建密集向量描述符。最后应使用 musparseDestroyDnVec() 销毁。

函数 musparseDestroyDnVec

MUSPARSE_EXPORT musparseStatus_t musparseDestroyDnVec(
    musparseDnVecDescr_t descr
)

销毁密集向量描述符。

参数：

descr 矩阵描述符。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_POINTER descr 无效。

musparseDestroyDnVec 销毁密集向量描述符并释放描述符使用的所

函数 musparseXbsrmv

MUSPARSE_EXPORT musparseStatus_t musparseXbsrmv()

使用BSR存储格式进行稀疏矩阵向量乘法。

参数：

handle muSPARSE 库上下文队列的句柄。
dir BSR块的矩阵存储方向。
trans 矩阵操作类型。
mb 稀疏BSR矩阵的块行数。
nb 稀疏BSR矩阵的块列数。
nnzb 稀疏BSR矩阵的非零块数。
alpha 标量 $\alpha$ 。
descr 稀疏BSR矩阵的描述符。目前，仅支持 MUSPARSE_MATRIX_TYPE_GENERAL。
bsr_val 包含稀疏BSR矩阵的 nnzb 个块的数组。
bsr_row_ptr 包含 mb+1 个元素的数组，指向稀疏BSR矩阵的每个块行的开始位置。
bsr_col_ind 包含 nnzb 个元素的数组，包含稀疏BSR矩阵的块列索引。
block_dim 稀疏BSR矩阵的块维度。
x 数组，包含 nb*block_dim 个元素（ $op(A) = A$ ）或 mb*block_dim 个元素（ $op(A) = A^T$ 或 $op(A) = A^H$ ）。
beta 标量 $\beta$ 。
y 数组，包含 mb*block_dim 个元素（ $op(A) = A$ ）或 nb*block_dim 个元素（ $op(A) = A^T$ 或 $op(A) = A^H$ ）。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb, nb, nnzb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER descr, alpha, bsr_val, bsr_row_ind, bsr_col_ind, x, beta 或 y 指针无效。
MUSPARSE_EXPORT MUSPARSE_STATUS_ARCH_MISMATCH 设备不受支持。
MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans != MUSPARSE_OPERATION_NON_TRANSPOSE 或 musparseMatrixType_t != MUSPARSE_MATRIX_TYPE_GENERAL。

注意：

此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。
目前，仅支持 trans == MUSPARSE_OPERATION_NON_TRANSPOSE。

MUSPARSE_EXPORT
musparseStatus_t musparseSbsrmv(musparseHandle_t handle,
                                musparseDirection_t dir,
                                musparseOperation_t trans, muInt mb, muInt nb,
                                muInt nnzb, const float* alpha,
                                const musparseMatDescr_t descr,
                                const float* bsr_val, const muInt* bsr_row_ptr,
                                const muInt* bsr_col_ind, muInt block_dim,
                                const float* x, const float* beta, float* y);

MUSPARSE_EXPORT
musparseStatus_t musparseDbsrmv(musparseHandle_t handle,
                                musparseDirection_t dir,
                                musparseOperation_t trans, muInt mb, muInt nb,
                                muInt nnzb, const double* alpha,
                                const musparseMatDescr_t descr,
                                const double* bsr_val, const muInt* bsr_row_ptr,
                                const muInt* bsr_col_ind, muInt block_dim,
                                const double* x, const double* beta, double* y);

MUSPARSE_EXPORT
musparseStatus_t musparseCbsrmv(musparseHandle_t handle,
                                musparseDirection_t dir, musparseOperation_t trans,
                                muInt mb, muInt nb, muInt nnzb, const muComplex* alpha,
                                const musparseMatDescr_t descr, const muComplex* bsr_val,
                                const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
                                const muComplex* x, const muComplex* beta, muComplex* y);

MUSPARSE_EXPORT
musparseStatus_t musparseZbsrmv(musparseHandle_t handle, 
                                musparseDirection_t dir, musparseOperation_t trans,
                                muInt mb, muInt nb, muInt nnzb, const muDoubleComplex* alpha,
                                const musparseMatDescr_t descr, const muDoubleComplex* bsr_val,
                                const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
                                const muDoubleComplex* x, const muDoubleComplex* beta, muDoubleComplex* y);

musparseXbsrmv 将标量 $\alpha$ 与定义在BSR存储格式中的稀疏 $(mb \cdot \text{block\_dim}) \times (nb \cdot \text{block\_dim})$ 矩阵相乘，以及密集向量 $x$ 并加上标量 $\beta$ 乘以的密集向量 $y$ 的结果，使得：

musparseXbsrmv 将标量 $\alpha$ 与定义在BSR存储格式中的稀疏 $(mb \cdot \text{block\_dim}) \times (nb \cdot \text{block\_dim})$ 矩阵相乘，以及密集向量 $x$ ，并加上标量 $\beta$ 乘以的密集向量 $y$ 的结果，使得：

y := \alpha \cdot op(A) \cdot x + \beta \cdot y

其中

op(A) = \begin{cases} A, & \text{if trans == MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \\ A^T, & \text{if trans == MUSPARSE\_OPERATION\_TRANSPOSE} \\ A^H, & \text{if trans == MUSPARSE\_OPERATION\_CONJUGATE\_TRANSPOSE} \end{cases}

函数 musparseXbsr2csr

MUSPARSE_EXPORT musparseStatus_t musparseXbsr2csr()

将稀疏BSR矩阵转换为稀疏CSR矩阵。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 块的存储格式，MUSPARSE_DIRECTION_ROW 或 MUSPARSE_DIRECTION_COLUMN
mb 稀疏BSR矩阵中的块行数。
nb 稀疏BSR矩阵中的块列数。
bsr_descr 稀疏BSR矩阵的描述符。目前，仅支持 MUSPARSE_MATRIX_TYPE_GENERAL。
bsr_val 包含 nnzb*block_dim*block_dim 个元素的数组，包含稀疏BSR矩阵的值。
bsr_row_ptr 包含 mb+1 个元素的数组，指向稀疏BSR矩阵的每个块行的开始位置。
bsr_col_ind 包含 nnzb 个元素的数组，包含稀疏BSR矩阵的块列索引。
block_dim 稀疏BSR矩阵中的块大小。
csr_descr 稀疏CSR矩阵的描述符。目前，仅支持 MUSPARSE_MATRIX_TYPE_GENERAL。
csr_val 包含 nnzb*block_dim*block_dim 个元素的数组，包含稀疏CSR矩阵的值。
csr_row_ptr 包含 m+1 个元素的数组，其中 m=mb*block_dim，指向稀疏CSR矩阵的每行的开始位置。
csr_col_ind 包含 nnzb*block_dim*block_dim 个元素的数组，包含稀疏CSR矩阵的列索引。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE mb 或 nb 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER bsr_val, bsr_row_ptr, bsr_col_ind, csr_val, csr_row_ptr 或 csr_col_ind 指针无效。

注意：此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

MUSPARSE_EXPORT
musparseStatus_t musparseSbsr2csr(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nb,
    const musparseMatDescr_t bsr_descr, const float* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    const musparseMatDescr_t csr_descr, float* csr_val, muInt* csr_row_ptr,
    muInt* csr_col_ind);

MUSPARSE_EXPORT
musparseStatus_t musparseDbsr2csr(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nb,
    const musparseMatDescr_t bsr_descr, const double* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    const musparseMatDescr_t csr_descr, double* csr_val, muInt* csr_row_ptr,
    muInt* csr_col_ind);

MUSPARSE_EXPORT
musparseStatus_t musparseCbsr2csr(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nb,
    const musparseMatDescr_t bsr_descr, const muComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    const musparseMatDescr_t csr_descr, muComplex* csr_val, muInt* csr_row_ptr,
    muInt* csr_col_ind);

MUSPARSE_EXPORT
musparseStatus_t musparseZbsr2csr(
    musparseHandle_t handle, musparseDirection_t dir, muInt mb, muInt nb,
    const musparseMatDescr_t bsr_descr, const muDoubleComplex* bsr_val,
    const muInt* bsr_row_ptr, const muInt* bsr_col_ind, muInt block_dim,
    const musparseMatDescr_t csr_descr, muDoubleComplex* csr_val,
    muInt* csr_row_ptr, muInt* csr_col_ind);

示例：

此示例将 BSR 矩阵转换为 CSR 矩阵。

     //     1 4 0 0 0 0
     // A = 0 2 3 0 0 0
     //     5 0 0 7 8 0
     //     0 0 9 0 6 0

     muInt mb   = 2;
     muInt nb   = 3;
     muInt block_dim = 2;
     muInt m = Mb * block_dim;
     muInt n = Nb * block_dim;

     bsr_row_ptr[mb+1]                 = {0, 2, 5}; // device memory
     bsr_col_ind[nnzb]                 = {0, 1, 0, 1, 2}; // device memory
     bsr_val[nnzb*block_dim*block_dim] = {1, 0, 4, 2, 0, 3, 0, 0, 5, 0, 0, 0,
0, 9, 7, 0, 8, 6, 0, 0}; // device memory

     muInt nnzb = bsr_row_ptr[mb] - bsr_row_ptr[0];

     // Create CSR arrays on device
     muInt* csr_row_ptr;
     muInt* csr_col_ind;
     float* csr_val;
     musaMalloc((void**)&csr_row_ptr, sizeof(muInt) * (m + 1));
     musaMalloc((void**)&csr_col_ind, sizeof(muInt) * nnzb *
block_dim * block_dim); musaMalloc((void**)&csr_val, sizeof(float) * nnzb *
block_dim * block_dim);

     // Create musparse handle
     musparse_local_handle handle;

     musparseMatDescr_t bsr_descr = nullptr;
     musparseCreateMatDescr(&bsr_descr);

     musparseMatDescr_t csr_descr = nullptr;
     musparseCreateMatDescr(&csr_descr);

     musparseSetMatIndexBase(bsr_descr, MUSPARSE_INDEX_BASE_ZERO);
     musparseSetMatIndexBase(csr_descr, MUSPARSE_INDEX_BASE_ZERO);

     // Format conversion
     musparseSbsr2csr(handle,
                        MUSPARSE_DIRECTION_COLUMN,
                        mb,
                        nb,
                        bsr_descr,
                        bsr_val,
                        bsr_row_ptr,
                        bsr_col_ind,
                        block_dim,
                        csr_descr,
                        csr_val,
                        csr_row_ptr,
                        csr_col_ind);

musparseXbsr2csr 将BSR矩阵转换为CSR矩阵。假设 csr_val, csr_col_ind 和 csr_row_ptr 已分配。csr_row_ptr 的分配大小由块行数乘以块维度再加一计算得出。csr_val 和 csr_col_ind 的分配由BSR矩阵中的块数乘以块维度的平方计算得出。

函数 musparseXcsr2bsr

MUSPARSE_EXPORT musparseStatus_t musparseXcsr2bsr()

将稀疏CSR矩阵转换为稀疏BSR矩阵。

参数：

handle muSPARSE 库上下文队列的句柄。
dir 块的存储格式，MUSPARSE_DIRECTION_ROW 或 MUSPARSE_DIRECTION_COLUMN
m 稀疏CSR矩阵中的行数。
n 稀疏CSR矩阵中的列数。
csr_descr 稀疏CSR矩阵的描述符。目前，仅支持 MUSPARSE_MATRIX_TYPE_GENERAL。
csr_val 包含 nnz 个元素的数组，包含稀疏CSR矩阵的值。
csr_row_ptr 包含 m+1 个元素的数组，指向稀疏CSR矩阵的每行的开始位置。
csr_col_ind 包含 nnz 个元素的数组，包含稀疏CSR矩阵的列索引。
block_dim 稀疏BSR矩阵中的块大小。
bsr_descr 稀疏BSR矩阵的描述符。目前，仅支持 MUSPARSE_MATRIX_TYPE_GENERAL。
bsr_val 包含 nnzb*block_dim*block_dim 个元素的数组，包含稀疏BSR矩阵的值。
bsr_row_ptr 包含 mb+1 个元素的数组，指向稀疏BSR矩阵的每个块行的开始位置。
bsr_col_ind 包含 nnzb 个元素的数组，包含稀疏BSR矩阵的块列索引。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_SIZE m 或 n 或 block_dim 无效。
MUSPARSE_STATUS_INVALID_POINTER bsr_val, bsr_row_ptr, bsr_col_ind, csr_val, csr_row_ptr 或 csr_col_ind 指针无效。

示例：

此示例将CSR矩阵转换为BSR矩阵。

//     1 4 0 0 0 0
// A = 0 2 3 0 0 0
//     5 0 0 7 8 0
//     0 0 9 0 6 0

muInt m   = 4;
muInt n   = 6;
muInt block_dim = 2;
muInt nnz = 9;
muInt mb = (m + block_dim - 1) / block_dim;
muInt nb = (n + block_dim - 1) / block_dim;

csr_row_ptr[m+1]  = {0, 2, 4, 7, 9};             // device memory
csr_col_ind[nnz]  = {0, 1, 1, 2, 0, 3, 4, 2, 4}; // device memory
csr_val[nnz]      = {1, 4, 2, 3, 5, 7, 8, 9, 6}; // device memory

musaMalloc(&bsr_row_ptr, sizeof(muInt) *(mb + 1));
muInt nnzb;
muInt* nnzTotalHostPtr = &nnzb;
csr2bsr_nnz(handle,
            MUSPARSE_DIRECTION_ROW,
            m,
            n,
            csr_descr,
            csr_row_ptr,
            csr_col_ind,
            block_dim,
            bsr_descr,
            bsr_row_ptr,
            nnzTotalHostPtr);
nnzb = *nnzTotalDevHostPtr;
musaMalloc(&bsr_col_ind, sizeof(int)*nnzb);
musaMalloc(&bsr_val, sizeof(float)*(block_dim * block_dim) * nnzb);
scsr2bsr(handle,
         MUSPARSE_DIRECTION_ROW,
         m,
         n,
         csr_descr,
         csr_val,
         csr_row_ptr,
         csr_col_ind,
         block_dim,
         bsr_descr,
         bsr_val,
         bsr_row_ptr,
         bsr_col_ind);

musparseXcsr2bsr 将 CSR 矩阵转换为BSR矩阵。假设 bsr_val, bsr_col_ind 和 bsr_row_ptr 已分配。bsr_row_ptr 的分配大小计算为 mb+1，其中 mb 是 BSR 矩阵中的块行数。bsr_val 和 bsr_col_ind 的分配大小使用 csr2bsr_nnz() 计算，该函数还填充 bsr_row_ptr。

musparseXcsr2bsr 需要额外的临时存储，如果 block_dim>16，则内部分配。

MUSPARSE_EXPORT
musparseStatus_t musparseScsr2bsr(
    musparseHandle_t handle, musparseDirection_t dir, muInt m, muInt n,
    const musparseMatDescr_t csr_descr, const float* csr_val,
    const muInt* csr_row_ptr, const muInt* csr_col_ind, muInt block_dim,
    const musparseMatDescr_t bsr_descr, float* bsr_val, muInt* bsr_row_ptr,
    muInt* bsr_col_ind);

MUSPARSE_EXPORT
musparseStatus_t musparseDcsr2bsr(
    musparseHandle_t handle, musparseDirection_t dir, muInt m, muInt n,
    const musparseMatDescr_t csr_descr, const double* csr_val,
    const muInt* csr_row_ptr, const muInt* csr_col_ind, muInt block_dim,
    const musparseMatDescr_t bsr_descr, double* bsr_val, muInt* bsr_row_ptr,
    muInt* bsr_col_ind);

MUSPARSE_EXPORT
musparseStatus_t musparseCcsr2bsr(
    musparseHandle_t handle, musparseDirection_t dir, muInt m, muInt n,
    const musparseMatDescr_t csr_descr, const muComplex* csr_val,
    const muInt* csr_row_ptr, const muInt* csr_col_ind, muInt block_dim,
    const musparseMatDescr_t bsr_descr, muComplex* bsr_val, muInt* bsr_row_ptr,
    muInt* bsr_col_ind);

MUSPARSE_EXPORT
musparseStatus_t musparseZcsr2bsr(
    musparseHandle_t handle, musparseDirection_t dir, muInt m, muInt n,
    const musparseMatDescr_t csr_descr, const muDoubleComplex* csr_val,
    const muInt* csr_row_ptr, const muInt* csr_col_ind, muInt block_dim,
    const musparseMatDescr_t bsr_descr, muDoubleComplex* bsr_val,
    muInt* bsr_row_ptr, muInt* bsr_col_ind);

函数 musparseSparseToDense

MUSPARSE_EXPORT musparseStatus_t musparseSparseToDense(
    musparseHandle_t handle,
    const musparseSpMatDescr_t mat_A,
    musparseDnMatDescr_t mat_B,
    musparseSparseToDenseAlg_t alg,
    size_t * buffer_size,
    void * temp_buffer
)

稀疏矩阵转换为密集矩阵。

参数：

handle muSPARSE 库上下文队列的句柄。
mat_A 稀疏矩阵描述符。
mat_B 密集矩阵描述符。
alg 稀疏到密集计算的算法。
buffer_size 临时存储缓冲区的字节数。当 temp_buffer 为 nullptr 时，buffer_size 被设置。
temp_buffer 用户分配的临时存储缓冲区。当传递 nullptr 时，将所需分配大小（以字节为单位）写入 buffer_size，函数返回而不执行稀疏到密集的操作。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER mat_A, mat_B, 或 buffer_size 指针无效。

注意：

此函数将所需分配大小（以字节为单位）写入 buffer_size 并返回而不执行稀疏到密集的操作，当传递 nullptr 给 temp_buffer。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseSparseToDense 执行 CSR, CSC, 或 COO 格式的稀疏矩阵到密集矩阵的转换

函数 musparseDenseToSparse

MUSPARSE_EXPORT musparseStatus_t musparseDenseToSparse(
    musparseHandle_t handle,
    const musparseDnMatDescr_t mat_A,
    musparseSpMatDescr_t mat_B,
    musparseDenseToSparseAlg_t alg,
    size_t * buffer_size,
    void * temp_buffer
)

密集矩阵转换为稀疏矩阵。

参数：

handle muSPARSE 库上下文队列的句柄。
mat_A 密集矩阵描述符。
mat_B 稀疏矩阵描述符。
alg 稀疏到密集计算的算法。
buffer_size 临时存储缓冲区的字节数。当 temp_buffer 为 nullptr 时，buffer_size 被设置。
temp_buffer 用户分配的临时存储缓冲区。当传递 nullptr 时，将所需分配大小（以字节为单位）写入 buffer_size，函数返回而不执行密集到稀疏的操作。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER mat_A, mat_B, 或 buffer_size 指针无效。

注意：

此函数将所需分配大小（以字节为单位）写入 buffer_size 并返回而不执行密集到稀疏的操作，当传递 nullptr 给 temp_buffer。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseDenseToSparse 执行密集矩阵到 CSR, CSC, 或 COO格式的稀疏矩阵的转换

函数 musparseAxpby

MUSPARSE_EXPORT musparseStatus_t musparseAxpby(
    musparseHandle_t handle,
    const void * alpha,
    const musparseSpVecDescr_t x,
    const void * beta,
    musparseDnVecDescr_t y
)

缩放稀疏向量并添加到缩放的密集向量。

参数：

handle muSPARSE 库上下文队列的句柄。
alpha 标量 $\alpha$ 。
x 稀疏矩阵描述符。
beta 标量 $\beta$ 。
y 密集矩阵描述符。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER alpha, x, beta 或 y 指针无效。

注意：此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseAxpby 将稀疏向量 $x$ 乘以标量 $\alpha$ 并添加到乘以标量 $\beta$ 的密集向量 $y$ 的结果，使得

y := \alpha \cdot x + \beta \cdot y

for(i = 0; i < nnz; ++i)
{
   y[x_ind[i]] = alpha * x_val[i] + beta * y[x_ind[i]]
}

函数 musparseSpVV

MUSPARSE_EXPORT musparseStatus_t musparseSpVV(
    musparseHandle_t handle,
    musparseOperation_t trans,
    const musparseSpVecDescr_t x,
    const musparseDnVecDescr_t y,
    void * result,
    musparseDataType_t compute_type,
    size_t * buffer_size,
    void * temp_buffer
)

稀疏向量内点积。

参数：

handle muSPARSE 库上下文队列的句柄。
trans 稀疏向量操作类型。
x 稀疏向量描述符。
y 密集向量描述符。
result 结果指针，可以是主机或设备内存
compute_type SpVV 计算的浮点精度。
buffer_size 临时存储缓冲区的字节数。当 temp_buffer 为 nullptr 时，buffer_size 被设置。
temp_buffer 用户分配的临时存储缓冲区。当传递 nullptr 时，将所需分配大小（以字节为单位）写入 buffer_size，函数返回而不执行SpVV操作。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER x, y, result 或 buffer_size 指针无效
***** MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED compute_type 当前不受支持。

注意：

此函数将所需分配大小（以字节为单位）写入 buffer_size 并返回而不执行SpVV操作，当传递 nullptr 给 temp_buffer。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。

musparseSpVV 计算稀疏向量 $x$ 与密集向量 $y$ 的内点积，使得

\text{result} := x^{'} \cdot y,

其中

op(x) = \begin{cases} x, & \text{if trans == MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \\ \bar{x}, & \text{if trans == MUSPARSE\_OPERATION\_CONJUGATE\_TRANSPOSE} \end{cases}

result = 0;
for(i = 0; i < nnz; ++i)
{
    result += x_val[i] * y[x_ind[i]];
}

函数 musparseSpSV

MUSPARSE_EXPORT musparseStatus_t musparseSpSV(
    musparseHandle_t handle,
    musparseOperation_t trans,
    const void * alpha,
    const musparseSpMatDescr_t mat,
    const musparseDnVecDescr_t x,
    const musparseDnVecDescr_t y,
    musparseDataType_t compute_type,
    musparseSpSVAlg_t alg,
    musparseSpSVStage_t stage,
    size_t * buffer_size,
    void * temp_buffer
)

稀疏三角求解。

参数：

handle muSPARSE 库上下文队列的句柄。
trans 矩阵操作类型。
alpha 标量 $\alpha$ 。
mat 矩阵描述符。
x 向量描述符。
y 向量描述符。
compute_type SpSV 计算的浮点精度。
alg SpSV 计算的 SpSV 算法。
stage SpSV 计算的 SpSV 阶段。
buffer_size 临时存储缓冲区的字节数。
temp_buffer 用户分配的临时存储缓冲区。当传递 nullptr 时，将所需分配大小（以字节为单位）写入 buffer_size，函数返回而不执行 SpSV 操作。

返回值：

MUSPARSE_STATUS_SUCCESS 操作成功完成。
MUSPARSE_STATUS_INVALID_HANDLE 库上下文未初始化。
MUSPARSE_STATUS_INVALID_POINTER alpha, mat, x, y, descr 或 buffer_size 指针无效
***** MUSPARSE_EXPORT MUSPARSE_STATUS_NOT_IMPLEMENTED trans, compute_type, stage 或 alg 当前不受支持。

注意：

SpSV 需要三个阶段来完成。第一阶段 MUSPARSE_SPSV_STAGE_BUFFER_SIZE 将返回临时存储缓冲区所需的大小，以供后续调用。第二阶段 MUSPARSE_SPSV_STAGE_PREPROCESS 将预处理数据，这些数据将保存在临时存储缓冲区中。在最后阶段 MUSPARSE_SPSV_STAGE_COMPUTE，执行实际的计算。
如果选择了 MUSPARSE_SPSV_STAGE_AUTO，musparse 将根据以下指标自动检测需要哪个阶段：如果 temp_buffer 等于 nullptr，则返回所需的缓冲区大小。如果 buffer_size 等于 nullptr，则执行分析。否则，将执行 SpSV 预处理和SpSV算法。
此函数是非阻塞的，并且与主机异步执行。它可能在实际计算完成之前返回。
目前，仅支持 trans == MUSPARSE_OPERATION_NON_TRANSPOSE 和 trans == MUSPARSE_OPERATION_TRANSPOSE。

musparse_spsv_solve 解决一个稀疏三角线性系统，一个定义在CSR或COO存储格式中的稀疏 $m \times m$ 矩阵，一个密集解向量 $y$ 和乘以 $\alpha$ 的右手边 $x$ ，使得 $op(A) \cdot y = \alpha \cdot x,$ 其中

op(A) = \begin{cases} A, & \text{if trans == MUSPARSE\_OPERATION\_NON\_TRANSPOSE} \\ A^T, & \text{if trans == MUSPARSE\_OPERATION\_TRANSPOSE} \\ A^H, & \text{if trans == MUSPARSE\_OPERATION\_CONJUGATE\_TRANSPOSE} \end{cases}

函数文档​

函数 musparseSetMatDiagType​

函数 musparseSetMatFillMode​

函数 musparseSetMatIndexBase​

函数 musparseXbsrsv_bufferSize​

函数 musparseXbsrsv_analysis​

函数 musparseXbsrsv_solve​

函数 musparseXbsrsv_zeroPivot​

函数 musparseXbsrsm_bufferSize​

函数 musparseXbsrsm_analysis​

函数 musparseXbsrsm_solve​

函数 musparseXbsrsm_zeroPivot​

函数 musparseXbsrilu0_numericBoost​

函数 musparseXbsrilu0_bufferSize​

函数 musparseXbsrilu0_analysis​

函数 musparseXbsrilu0​

函数 musparseXbsrilu0_zeroPivot​

函数 musparseCreate​

函数 musparseDestroy​

函数 musparseCreateMatDescr​

函数 musparseDestroyMatDescr​

函数 musparseGetMatDiagType​

函数 musparseGetMatFillMode​

函数 musparseGetMatIndexBase​

函数 musparseGetMatType​

函数 musparseXbsrmm​

函数 musparseXcsric0_bufferSize​

函数 musparseXcsric0_analysis​

函数 musparseXcsric0​

函数 musparseXcsric0_zeroPivot​

函数 musparseXbsric0_bufferSize​

函数 musparseXbsric0_analysis​

函数 musparseXbsric0​

函数 musparseXbsric0_zeroPivot​

函数 musparseXcsrilu0_numericBoost​

函数 musparseXcsrilu0_bufferSize​

函数 musparseXcsrilu0_analysis​

函数 musparseXcsrilu0​

函数 musparseXcsrilu0_zeroPivot​

函数 musparseCreateCsr​

函数 musparseCreateDnVec​

函数 musparseDestroyDnVec​

函数 musparseXbsrmv​

函数 musparseXbsr2csr​

函数 musparseXcsr2bsr​

函数 musparseSparseToDense​

函数 musparseDenseToSparse​

函数 musparseAxpby​

函数 musparseSpVV​

函数 musparseSpSV​

这篇文章对您有帮助吗？

函数文档

函数 musparseSetMatDiagType

函数 musparseSetMatFillMode

函数 musparseSetMatIndexBase

函数 musparseXbsrsv_bufferSize

函数 musparseXbsrsv_analysis

函数 musparseXbsrsv_solve

函数 musparseXbsrsv_zeroPivot

函数 musparseXbsrsm_bufferSize

函数 musparseXbsrsm_analysis

函数 musparseXbsrsm_solve

函数 musparseXbsrsm_zeroPivot

函数 musparseXbsrilu0_numericBoost

函数 musparseXbsrilu0_bufferSize

函数 musparseXbsrilu0_analysis

函数 musparseXbsrilu0

函数 musparseXbsrilu0_zeroPivot

函数 musparseCreate

函数 musparseDestroy

函数 musparseCreateMatDescr

函数 musparseDestroyMatDescr

函数 musparseGetMatDiagType

函数 musparseGetMatFillMode

函数 musparseGetMatIndexBase

函数 musparseGetMatType

函数 musparseXbsrmm

函数 musparseXcsric0_bufferSize

函数 musparseXcsric0_analysis

函数 musparseXcsric0

函数 musparseXcsric0_zeroPivot

函数 musparseXbsric0_bufferSize

函数 musparseXbsric0_analysis

函数 musparseXbsric0

函数 musparseXbsric0_zeroPivot

函数 musparseXcsrilu0_numericBoost

函数 musparseXcsrilu0_bufferSize

函数 musparseXcsrilu0_analysis

函数 musparseXcsrilu0

函数 musparseXcsrilu0_zeroPivot

函数 musparseCreateCsr

函数 musparseCreateDnVec

函数 musparseDestroyDnVec

函数 musparseXbsrmv

函数 musparseXbsr2csr

函数 musparseXcsr2bsr

函数 musparseSparseToDense

函数 musparseDenseToSparse

函数 musparseAxpby

函数 musparseSpVV

函数 musparseSpSV