11. mcSPARSE预处理器参考
本章描述了实现不同预处理器的例程。
11.1. 不完全Cholesky分解：0 级
该部分讨论了用于ic0的不同算法。
11.1.1. mcsparse<t>csric02_bufferSize()
mcsparseStatus_t
mcsparseScsric02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseDcsric02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseCcsric02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseZcsric02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
int* pBufferSizeInBytes)
此函数返回用于计算不完全Cholesky因式分解(0填充和无主元)的缓冲区大小。
A是一个 m×m 的稀疏矩阵，是由三个数组 csrValA 、 csrRowPtrA 和 csrColIndA 在CSR存储格式中定义的。
缓冲区大小取决于维度 m 和矩阵非零元素的数量 nnz。
如果用户更改了矩阵，需要再次调用 csric02_bufferSize() 函数来获取正确的缓冲区大小；否则可能会导致段错误。
该例程不需要额外的存储空间
该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵
A的行数和列数。nnz矩阵
A的非零元素个数。descrA矩阵
A的描述符。 支持的矩阵类型是MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA<type>数组，包含矩阵
A中nnz个非零元素。csrRowPtrA包含 m + 1 个元素的整数数组，其中 存储了每行的起始位置和最后一行结 束位置加一的值。
csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。输出
info根据不同算法记录内部状态。
pBufferSizeInBytescsric02_analysis()和csric02()使 用的缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.1.2. mcsparse<t>csric02_analysis()
mcsparseStatus_t
mcsparseScsric02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsric02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsric02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsric02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行不完全Cholesky因式分解(0填充，无主元)的分析阶段：
此函数需要一个由 csric02_bufferSize() 返回的缓冲区大小。 pBuffer 的地址必须是128字节的倍数。
如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
函数 csric02_analysis() 报告一个结构零，并计算存储在不透明结构 info 中的级别信息。
级别信息可以在不完全 Cholesky 因式分解过程中提高并行效率。
然而， csric02() 函数可以在没有级别信息的情况下执行。
为了禁用级别信息，用户必须将 csric02_analysis() 和 csric02() 的策略指定为 MCSPARSE_SOLVE_POLICY_NO_LEVEL。
即使策略是 MCSPARSE_SOLVE_POLICY_NO_LEVEL， csric02_analysis() 函数始终报告第一个结构零。
用户需要调用 mcsparseXcsric02_zeroPivot() 函数来获取结构零的位置信息。
如果 csric02_analysis() 报告一个结构零，用户可自行决定是否调用 csric02()。
在这种情况下，用户仍然可以调用 csric02() 函数，它将在与结构零相同的位置返回一个数值零。
然而，结果是没有意义的。
此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄
m矩阵A的行数和列数。
nnz矩阵A的非零元素个数。
descrA矩阵 A 的描述符。 支持的矩阵类型为
MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基地址为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA<type>数组，包含矩阵
A中nnz个非零元素。csrRowPtrA包含 m + 1 个元素的整数数组，其中 存储了每行的起始位置和最后一行结 束位置加一的值。
csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。info用
mcsparseCreateCsric02Info()函数初始化结构体。policy支持的策略是
MCSPARSE_SOLVE_POLICY_NO_LEVEL和MCSPARSE_SOLVE_POLICY_USE_LEVELpBuffer用户分配的缓冲区：大小由
csric02_bufferSize()函数返回。输出
info在
csric02_analysis()和csric02()中使用的缓冲区 的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.1.3. mcsparse<t>csric02()
mcsparseStatus_t
mcsparseScsric02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
float* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsric02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
double* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsric02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcComplex* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsric02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csric02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行不完全cholesky因式分解计算(0填充、无主元)的求解阶段：
此函数需要由 csric02_bufferSize() 函数返回的缓冲区大小。
pBuffer 的地址必须是128字节的倍数。
如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
虽然 csric02() 函数可以在没有级别信息的情况下进行，但用户仍需注意一致性。
如果在调用 csric02_analysis() 时使用了策略 MCSPARSE_SOLVE_POLICY_USE_LEVEL，那么 csric02() 可以在有或没有级别信息的情况下运行。
另一方面，如果使用 MCSPARSE_SOLVE_POLICY_NO_LEVEL 调用 csric02_analysis() 函数，则 csric02() 函数只能接受 MCSPARSE_SOLVE_POLICY_NO_LEVEL ；
否则，返回 MCSPARSE_STATUS_INVALID_VALUE。
函数 csric02() 报告第一个数值零，包括结构零。
用户必须调用 mcsparseXcsric02_zeroPivot() 以知道数值零的位置。
函数 csric02() 只使用矩阵A的下三角部分进行因式分解。
矩阵类型必须是 MCSPARSE_MATRIX_TYPE_GENERAL，填充模式和对角线类型将被忽略，严格意义上三角部分被忽略且永远不会被修改。
至于A是否是厄米矩阵并不重要。即，从 csric02() 的角度看，A是厄米矩阵，只提供了下三角部分。
备注
在实际应用中，正定矩阵可能没有不完全Cholesky因式分解。
据我们所知，只有矩阵M可以保证存在不完全Cholesky因式分解。
如果 csric02() 未能进行Cholesky因式分解并报告了数值零，则可能不存在不完全Cholesky因式分解。
例如，假设 A 是一个实数 m×m 的矩阵，以下代码求解了预条件系统 M * y = x，其中 M 是Cholesky因式分解 L 及其转置的乘积。
如果 pBuffer != NULL，此函数支持以下特性：
此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器可用，则该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵A的行数和列数。
nnz矩阵A的非零元素个数。
descrA矩阵 A 的描述符。 支持的矩阵类型为
MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基地址为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA_valM<type>数组，包含矩阵
A中nnz个非零元素。csrRowPtrA包含 m + 1 个元素的整数数组，其中 存储了每行的起始位置和最后一行结 束位置加一的值。
csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。info结构与分析阶段收集的信息相对应 (这些信息应该在求解阶段中保持不 变)。
policy支持的策略是
MCSPARSE_SOLVE_POLICY_NO_LEVEL和MCSPARSE_SOLVE_POLICY_USE_LEVELpBuffer用户分配的缓冲区：大小由
csric02_bufferSize()函数返回。输出
csrValA_valM包含不完全Cholesky下三角因式的<type>矩阵。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.1.4. mcsparseXcsric02_zeroPivot()
mcsparseStatus_t
mcsparseXcsric02_zeroPivot(mcsparseHandle_t handle,
csric02Info_t info,
int* position)
如果返回的错误代码是 MCSPARSE_STATUS_ZERO_PIVOT，则position=j表示A(j,j)要么是结构零，要么是数值零：
否则，position=-1。
position可以是以0为基准或者以1为基准，和矩阵一样。
函数 mcsparseXcsric02_zeroPivot() 是一个阻塞调用。
它调用 mcDeviceSynchronize() 函数确保所有之前的核都已完成。
position 可以在主机内存或设备内存中。
用户可以使用 mcsparseSetPointerMode() 来设置适当的模式。
该例程不需要额外的存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
info如果用户已经调用了
csric02_analysis()或csric02()，则info包含结构零或数值零。输出
position如果没有结构性或数值上的零，则
position为-1；否则 ，如果A(j,j)缺失或L(j,j)为零，则position=j。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.2. 不完全LU分解：0 级
本节中讨论了ilu0的不同算法。
11.2.1. mcsparse<t>csrilu02_numericBoost()
mcsparseStatus_t
mcsparseScsrilu02_numericBoost(mcsparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double* tol,
float* boost_val)
mcsparseStatus_t
mcsparseDcsrilu02_numericBoost(mcsparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double* tol,
double* boost_val)
mcsparseStatus_t
mcsparseCcsrilu02_numericBoost(mcsparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double* tol,
mcComplex* boost_val)
mcsparseStatus_t
mcsparseZcsrilu02_numericBoost(mcsparseHandle_t handle,
csrilu02Info_t info,
int enable_boost,
double* tol,
mcDoubleComplex* boost_val)
用户可以使用boost值来替换不完全LU因式分解中的数值。
tol 用于确定一个数值零， boost_val 用于替换数值零。
如果 tol >= fabs(A(j,j))，则 A(j,j)=boost_val。
要启用boost值，在调用 csrilu02() 之前，用户必须将参数 enable_boost 设置为1。
要禁用boost值，用户可以再次调用带有参数 enable_boost=0 的 csrilu02_numericBoost() 函数。
如果 enable_boost=0，则忽略 tol 和 boost_val。
tol 和 boost_val 都可以在主机内存或设备内存中。
用户可以使用 mcsparseSetPointerMode() 函数设置适当的模式。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
info使用
mcsparseCreateCsrilu02Info()进行初始化 结构。enable_boost通过
enable_boost=0禁用boost值；否则， 启用boost值。tol用于确定数值零的容差。
boost_val用于替换数值零的boost值。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.2.2. mcsparse<t>csrilu02_bufferSize()
mcsparseStatus_t
mcsparseScsrilu02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseDcsrilu02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseCcsrilu02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
int* pBufferSizeInBytes)
mcsparseStatus_t
mcsparseZcsrilu02_bufferSize(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
int* pBufferSizeInBytes)
此函数返回用于计算不完全LU因式分解(0填充，无主元)的缓冲区大小。
A 是一个由三个数组 csrValA 、 csrRowPtrA 和 csrColIndA 在CSR存储格式中定义的 mxm 的稀疏矩阵。
缓冲区大小取决于维度m和矩阵的非零元素数 nnz。
如果用户更改了矩阵，需要再次调用 csrilu02_bufferSize() 函数来获得正确的缓冲区大小；否则可能会导致分段错误。
该例程不需要额外的存储空间
该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵A的行数和列数。
nnz矩阵A的非零元素个数。
descrA矩阵A的描述符。 支持的矩阵类型为
MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基地址为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA<type>数组，包含矩阵
A中nnz个非零元素。csrRowPtrA包含 m + 1 个元素的整数数组，其中 存储了每行的起始位置和最后一行结 束位置加一的值。
csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。输出
info根据不同算法记录内部状态。
pBufferSizeInBytescsric02_analysis()和csric02()使用的缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.2.3. mcsparse<t>csrilu02_analysis()
mcsparseStatus_t
mcsparseScsrilu02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const float* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsrilu02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const double* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsrilu02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const mcComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsrilu02_analysis(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
const mcDoubleComplex* csrValA,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行不完全LU分解(0填充，无主元)的分析阶段。
A 是一个由三个数组 csrValA 、 csrRowPtrA 和 csrColIndA 在CSR存储格式中定义的 mxm 的稀疏矩阵。
此函数需要由 csrilu02_bufferSize() 返回的缓冲区大小。 pBuffer 的地址必须是128字节的倍数。如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
函数 csrilu02_analysis() 报告一个结构零，并计算存储在不透明结构体 info 中的级别信息。
级别信息可以在不完全LU分解过程中提高并行效率。
然而， csrilu02() 也可以在没有级别信息的情况下执行。
要禁用级别信息，用户必须将 csrilu02() 的策略设置为 MCSPARSE_SOLVE_POLICY_NO_LEVEL。
如果 csrilu02_analysis() 报告一个结构零，用户可以选择是否调用 csrilu02()。
在这种情况下，用户仍然可以调用 csrilu02()，它将在与结构零相同的位置返回一个数值零。
然而，结果是没有意义的。
此函数需要内部分配的额外临时存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵A的行数和列数。
nnz矩阵A的非零元素个数。
descrA矩阵A的描述符。 支持的矩阵类型为
MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基地址为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA<type>数组，包含矩阵
A中nnz个非零元素。csrRowPtrA包含 m + 1 个元素的整数数组，其中 存储了每行的起始位置和最后一行结 束位置加一的值。
csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。info使用mcsparseCreateCsrilu02Info() 函数初始化结构。
policy支持的策略是
MCSPARSE_SOLVE_POLICY_NO_LEVEL和MCSPARSE_SOLVE_POLICY_USE_LEVELpBuffer用户分配的缓冲区：大小由
csrilu02_bufferSize()函数返回 。输出
info在分析阶段收集信息的结构(应该在求解阶段传递时保持不 变)。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.2.4. mcsparse<t>csrilu02()
mcsparseStatus_t
mcsparseScsrilu02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
float* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseDcsrilu02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
double* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseCcsrilu02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcComplex* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
mcsparseStatus_t
mcsparseZcsrilu02(mcsparseHandle_t handle,
int m,
int nnz,
const mcsparseMatDescr_t descrA,
mcDoubleComplex* csrValA_valM,
const int* csrRowPtrA,
const int* csrColIndA,
csrilu02Info_t info,
mcsparseSolvePolicy_t policy,
void* pBuffer)
此函数执行不完全LU因式分解(0填充，无主元)的求解阶段。
A 是一个由三个数组 csrValA_valM 、 csrRowPtrA 和 csrColIndA 在CSR存储格式中定义的 mxm 稀疏矩阵。
此函数需要由 csrilu02_bufferSize() 返回的缓冲区大小。
pBuffer 的地址必须是128字节的倍数。
如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
矩阵类型必须是 MCSPARSE_MATRIX_TYPE_GENERAL。
填充模式和对角线类型被忽略。
虽然 csrilu02() 可以在没有级别信息的情况下进行，但用户仍然需要注意一致性。
如果在调用 csrilu02_analysis() 时使用了策略 MCSPARSE_SOLVE_POLICY_USE_LEVEL，那么 csrilu02() 可以在有或没有级别信息的情况下运行。
另一方面，如果调用 csrilu02_analysis() 时使用了策略 MCSPARSE_SOLVE_POLICY_NO_LEVEL，那么 csrilu02() 只能接受 MCSPARSE_SOLVE_POLICY_NO_LEVEL；否则，返回 MCSPARSE_STATUS_INVALID_VALUE。
函数 csrilu02() 报告第一个数值零，包括结构零。
用户必须调用 mcsparseXcsrilu02_zeroPivot() 来知道数值零的位置。
例如，假设 A 是一个实数 mxm 矩阵，以下代码求解了预处理系统 M*y = x，其中 M 是LU因子 L 和 U 的乘积。
// 假设A是 m x m 的稀疏矩阵，以 CSR 格式表示。 // 假设条件： // - 句柄已经由mcsparseCreate()创建。 // - (d_csrRowPtr, d_csrColInd, d_csrVal) 是A在设备内存中的 CSR 表示。 // - d_x 是右侧向量在设备内存中的表示。 // - d_y 是解向量在设备内存中的表示。 // - d_z 是中间结果在设备内存中的表示。 mcsparseMatDescr_t descr_M = 0; mcsparseMatDescr_t descr_L = 0; mcsparseMatDescr_t descr_U = 0; csrilu02Info_t info_M = 0; csrsv2Info_t info_L = 0; csrsv2Info_t info_U = 0; int pBufferSize_M; int pBufferSize_L; int pBufferSize_U; int pBufferSize; void *pBuffer = 0; int structural_zero; int numerical_zero; const double alpha = 1.; const mcsparseSolvePolicy_t policy_M = MCSPARSE_SOLVE_POLICY_NO_LEVEL; const mcsparseSolvePolicy_t policy_L = MCSPARSE_SOLVE_POLICY_NO_LEVEL; const mcsparseSolvePolicy_t policy_U = MCSPARSE_SOLVE_POLICY_USE_LEVEL; const mcsparseOperation_t trans_L = MCSPARSE_OPERATION_NON_TRANSPOSE; const mcsparseOperation_t trans_U = MCSPARSE_OPERATION_NON_TRANSPOSE; // 步骤 1:创建一个描述符，其中包含 // - 矩阵 M 的基索引为 1 // - 矩阵 L 的基索引为 1 // - 矩阵 L 是下三角形 // - 矩阵 L 的对角线元素为 1 // - 矩阵 U 的基索引为 1 // - 矩阵 U 是上三角形 // - 矩阵 U 的对角线元素不为 1 mcsparseCreateMatDescr(&descr_M); mcsparseSetMatIndexBase(descr_M, MCSPARSE_INDEX_BASE_ONE); mcsparseSetMatType(descr_M, MCSPARSE_MATRIX_TYPE_GENERAL); mcsparseCreateMatDescr(&descr_L); mcsparseSetMatIndexBase(descr_L, MCSPARSE_INDEX_BASE_ONE); mcsparseSetMatType(descr_L, MCSPARSE_MATRIX_TYPE_GENERAL); mcsparseSetMatFillMode(descr_L, MCSPARSE_FILL_MODE_LOWER); mcsparseSetMatDiagType(descr_L, MCSPARSE_DIAG_TYPE_UNIT); mcsparseCreateMatDescr(&descr_U); mcsparseSetMatIndexBase(descr_U, MCSPARSE_INDEX_BASE_ONE); mcsparseSetMatType(descr_U, MCSPARSE_MATRIX_TYPE_GENERAL); mcsparseSetMatFillMode(descr_U, MCSPARSE_FILL_MODE_UPPER); mcsparseSetMatDiagType(descr_U, MCSPARSE_DIAG_TYPE_NON_UNIT); // 步骤 2:创建一个空的 info 结构体 // 我们需要一个 info 结构体用于 csrilu02,和两个 info 结构体用于 csrsv2 mcsparseCreateCsrilu02Info(&info_M); mcsparseCreateCsrsv2Info(&info_L); mcsparseCreateCsrsv2Info(&info_U); // 步骤 3:查询 csrilu02 和 csrsv2 中所使用的内存量，并分配缓冲区 mcsparseDcsrilu02_bufferSize(handle, m, nnz, descr_M, d_csrVal, d_csrRowPtr, d_csrColInd, info_M, &pBufferSize_M); mcsparseDcsrsv2_bufferSize(handle, trans_L, m, nnz, descr_L, d_csrVal, d_csrRowPtr, d_csrColInd, info_L, &pBufferSize_L); mcsparseDcsrsv2_bufferSize(handle, trans_U, m, nnz, descr_U, d_csrVal, d_csrRowPtr, d_csrColInd, info_U, &pBufferSize_U); pBufferSize = max(pBufferSize_M, max(pBufferSize_L, pBufferSize_U)); // mcMalloc 返回的 pBuffer 自动对齐到 128 字节。 mcMalloc((void**)&pBuffer, pBufferSize); // 步骤 4:对 M 执行不完全Cholesky分析 // 对 L 执行三角求解分析 // 对 U 执行三角求解分析 // M 的下(上)三角部分与 L(U)具有相同的稀疏模式， // 所以我们可以同时进行 csrilu0 和 csrsv2 的分析。 mcsparseDcsrilu02_analysis(handle, m, nnz, descr_M, d_csrVal, d_csrRowPtr, d_csrColInd, info_M, policy_M, pBuffer); status = mcsparseXcsrilu02_zeroPivot(handle, info_M, &structural_zero); if (MCSPARSE_STATUS_ZERO_PIVOT == status){ printf("A(%d,%d) is missing\n", structural_zero, structural_zero); } mcsparseDcsrsv2_analysis(handle, trans_L, m, nnz, descr_L, d_csrVal, d_csrRowPtr, d_csrColInd, info_L, policy_L, pBuffer); mcsparseDcsrsv2_analysis(handle, trans_U, m, nnz, descr_U, d_csrVal, d_csrRowPtr, d_csrColInd, info_U, policy_U, pBuffer); // 步骤 5:M = L * U mcsparseDcsrilu02(handle, m, nnz, descr_M, d_csrVal, d_csrRowPtr, d_csrColInd, info_M, policy_M, pBuffer); status = mcsparseXcsrilu02_zeroPivot(handle, info_M, &numerical_zero); if (MCSPARSE_STATUS_ZERO_PIVOT == status){ printf("U(%d,%d) is zero\n", numerical_zero, numerical_zero); } // 步骤 6:解 L*z = x mcsparseDcsrsv2_solve(handle, trans_L, m, nnz, &alpha, descr_L, d_csrVal, d_csrRowPtr, d_csrColInd, info_L, d_x, d_z, policy_L, pBuffer); // 步骤 7:解 U*y = z mcsparseDcsrsv2_solve(handle, trans_U, m, nnz, &alpha, descr_U, d_csrVal, d_csrRowPtr, d_csrColInd, info_U, d_z, d_y, policy_U, pBuffer); // 步骤 8:释放资源 mcFree(pBuffer); mcsparseDestroyMatDescr(descr_M); mcsparseDestroyMatDescr(descr_L); mcsparseDestroyMatDescr(descr_U); mcsparseDestroyCsrilu02Info(info_M); mcsparseDestroyCsrsv2Info(info_L); mcsparseDestroyCsrsv2Info(info_U); mcsparseDestroy(handle);
如果 pBuffer != NULL，此函数支持以下特性：
该例程不需要额外的存储空间
该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
m矩阵A的行数和列数。
nnz矩阵A的非零元素个数。
descrA矩阵A的描述符。 支持的矩阵类型为
MCSPARSE_MATRIX_TYPE_GENERAL。 此外，支持的索引基地址为MCSPARSE_INDEX_BASE_ZERO和MCSPARSE_INDEX_BASE_ONE。csrValA_valM<type>数组，包含矩阵
A中nnz个非零元素。csrRowPtrA包含 m + 1 个元素的整数数组，其中 存储了每行的起始位置和最后一行结 束位置加一的值。
csrColIndA整数数组，包含矩阵
A中nnz个非零元素的列索引。info结构与分析阶段收集的信息相对应 (这些信息应该在求解阶段中保持不变) 。
policy支持的策略是
MCSPARSE_SOLVE_POLICY_NO_LEVEL和MCSPARSE_SOLVE_POLICY_USE_LEVELpBuffer用户分配的缓冲区：大小由
csrilu02_bufferSize()函数返回 。输出
csrValA_valM<type>矩阵，包含不完全LU分解的下三角和上三角因子
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.2.5. mcsparseXcsrilu02_zeroPivot()
mcsparseStatus_t
mcsparseXcsrilu02_zeroPivot(mcsparseHandle_t handle,
csrilu02Info_t info,
int* position)
如果返回的错误代码是 MCSPARSE_STATUS_ZERO_PIVOT，则 position=j 表示 A(j,j) 存在结构零或数值零；
否则， position=-1。
position 可以是基于0或1的索引，与矩阵相同。
函数 mcsparseXcsrilu02_zeroPivot() 是一个阻塞调用。
它调用 mcDeviceSynchronize() 确保所有先前的核已完成。
position 可以在主机内存或设备内存中。
用户可以使用 mcsparseSetPointerMode() 设置适当的模式。
该例程不需要额外的存储空间
如果流式有序内存分配器可用，则该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
info如果用户已经调用了
csrilu02_analysis()或csrilu02()，则info包含结构零或数值零。输出
position如果没有结构零或数值零，则
position为-1; 否则，如果A(j,j)缺失或U(j,j)为零，则position=j。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.3. 三对角求解
三对角求解的不同求解算法在本部分中进行了讨论。
11.3.1. mcsparse<t>gtsv2_buffSizeExt()
mcsparseStatus_t
mcsparseSgtsv2_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const float* dl,
const float* d,
const float* du,
const float* B,
int ldb,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseDgtsv2_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const double* dl,
const double* d,
const double* du,
const double* B,
int ldb,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseCgtsv2_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
const mcComplex* B,
int ldb,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseZgtsv2_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
const mcDoubleComplex* B,
int ldb,
size_t* bufferSizeInBytes)
此函数返回在计算具有多个右侧向量的三对角线性系统解的 gtsv2 中使用的缓冲区大小。
A*X=B
每个三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于它的下对角线(dl)、主对角线 (d)和上对角线(du)；右侧向量存储在稠密矩阵 B 中。
请注意，在退出时，解 X 会覆盖右侧矩阵 B。
该例程不需要额外的存储空间
该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
m线性系统的大小(必须>= 3)。
n右侧向量的数量。 矩阵
B的列数。dl<type> 稠密数组，包含三对角线性系 统的下对角线。 每个下对角线的第一 个元素必须为零。
d<type> 稠密数组，包含三对角线性系 统的主对角线。
du<type> 稠密数组，包含三对角线性系 统的上对角线。每个上对角线的最后 一个元素必须为零。
B<type> 稠密右侧向量，维度为
(ldb, n)。ldbB的主维度。输出
pBufferSizeInBytesgtsv2中使用的缓冲区的字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.3.2. mcsparse<t>gtsv2()
mcsparseStatus_t
mcsparseSgtsv2(mcsparseHandle_t handle,
int m,
int n,
const float* dl,
const float* d,
const float* du,
float* B,
int ldb,
void pBuffer)
mcsparseStatus_t
mcsparseDgtsv2(mcsparseHandle_t handle,
int m,
int n,
const double* dl,
const double* d,
const double* du,
double* B,
int ldb,
void pBuffer)
mcsparseStatus_t
mcsparseCgtsv2(mcsparseHandle_t handle,
int m,
int n,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
mcComplex* B,
int ldb,
void pBuffer)
mcsparseStatus_t
mcsparseZgtsv2(mcsparseHandle_t handle,
int m,
int n,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
mcDoubleComplex* B,
int ldb,
void pBuffer)
此函数用于计算具有多个右侧的三对角线性系统的解：
A*X=B
每个三对角线性系统的系数矩阵 A 定义为三个向量，分别对应于它的下对角线(dl)、主对角线 (d)和上对角线(du)；右侧向量存储在稠密矩阵 B 中。
请注意，在退出时，解 X 会覆盖的右侧向量矩阵 B。
假设 A 的大小为 m，以 1 为基准， dl、 d 和 du 由以下公式定义：
对于
i=1,2,...,m，dl(i) := A(i, i-1)
dl 的第一个元素超出范围 (dl(1) := A(1,0))，因此 dl(1) = 0。
对于
i=1,2,...,m，d(i) = A(i,i)对于
i=1,2,...,m，du(i) = A(i,i+1)
du 的最后一个元素超出范围 (du(m) := A(m,m+1))，因此 du(m) = 0。
该例程执行了主元选取，通常比 mcsparse<t>gtsv_nopivot() 或 mcsparse<t>gtsv2_nopivot() 产生更准确和稳定的结果，但需要一些执行时间。
此函数需要由 gtsv2_bufferSizeExt() 返回的缓冲区大小。
pBuffer 的地址必须是 128 字节的倍数。
如果不是，则返回 MCSPARSE_STATUS_INVALID_VALUE。
该例程不需要额外的存储空间
该例程支持异步执行
输入
handle处理mcSPARSE库上下文的句柄。
m线性系统的大小(必须>= 3)。
n右侧向量的数量。 矩阵
B的列数。dl<type> 稠密数组，包含三对角线性系 统的下对角线。 每个下对角线的第一 个元素必须为零。
d<type> 稠密数组，包含三对角线性系 统的主对角线。
du<type> 稠密数组，包含三对角线性系 统的上对角线。每个上对角线的最后 一个元素必须为零。
B<type> 稠密右侧向量，维度为
(ldb, n)。ldbB的主维度。pBuffer用户分配的缓冲区，大小由
gtsv2_bufferSizeExt返回。输出
B(ldb, n) 维度的<type>稠密解数组。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.3.3. mcsparse<t>gtsv2_nopivot_bufferSizeExt()
mcsparseStatus_t
mcsparseSgtsv2_nopivot_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const float* dl,
const float* d,
const float* du,
const float* B,
int ldb,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseDgtsv2_nopivot_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const double* dl,
const double* d,
const double* du,
const double* B,
int ldb,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseCgtsv2_nopivot_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
const mcComplex* B,
int ldb,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseZgtsv2_nopivot_bufferSizeExt(mcsparseHandle_t handle,
int m,
int n,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
const mcDoubleComplex* B,
int ldb,
size_t* bufferSizeInBytes)
此函数返回 gtsv2_nopivot 中使用的缓冲区的大小，用于计算带有多个右侧的三对角线线性系统(tri-diagonal linear system )的解。
A*X=B
这些三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于它的下对角线( dl )、主对角线( d )和上对角线( du )；右侧的值存储在稠密矩阵 B 中。
请注意，在退出时，解 X 会覆盖右侧矩阵 B。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
m线性系统的规模大小。 (必须 >= 3)。
n矩阵B的右侧标识数和列数。
dl<type> 稠密数组，包含三对角线性系 统的下对角线。 每个下对角线的第一 个元素必须为零。
d<type> 稠密数组，包含三对角线性系 统的主对角线。
du<type> 稠密数组，包含三对角线性 系统的上对角线。每个上对角线的最 后一个元素必须为零。
B一个维度为
(ldb, n)的右侧<type>稠密数组。ldb矩阵
B的主维度。输出
pBufferSizeInBytes缓冲区使用的字节数
gtsv2_nopivot。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.3.4. mcsparse<t>gtsv2_nopivot()
mcsparseStatus_t
mcsparseSgtsv2_nopivot(mcsparseHandle_t handle,
int m,
int n,
const float* dl,
const float* d,
const float* du,
float* B,
int ldb,
void* pBuffer)
mcsparseStatus_t
mcsparseDgtsv2_nopivot(mcsparseHandle_t handle,
int m,
int n,
const double* dl,
const double* d,
const double* du,
double* B,
int ldb,
void* pBuffer)
mcsparseStatus_t
mcsparseCgtsv2_nopivot(mcsparseHandle_t handle,
int m,
int n,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
mcComplex* B,
int ldb,
void* pBuffer)
mcsparseStatus_t
mcsparseZgtsv2_nopivot(mcsparseHandle_t handle,
int m,
int n,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
mcDoubleComplex* B,
int ldb,
void* pBuffer)
此函数用来计算多个右侧的三对角线线性系统的解：
A*X=B
每个三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于它的下对角线( dl )、主对角线( d )和上对角线( du )；右侧的值存储在稠密矩阵 B 中。
请注意，在退出时，解 X 会覆盖右侧矩阵 B。
该程序不执行任何主元素选取操作，而是使用循环归约(Cyclic Reduction,CR)和并行循环归约(Parallel Cyclic Reduction,PCR)这两种算法的组合来求解。
当 m 是2次幂时，它可以实现更好的性能。
此函数需要一个由 gtsv2_nopivot_bufferSizeExt() 返回的缓冲区大小。
pBuffer 的地址必须是128字节的倍数。如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
m线性系统的规模大小。 (必须 >= 3)。
n矩阵B的右侧标识数和列数。
dl<type> 稠密数组，包含三对角线性系 统的下对角线。 每个下对角线的第一 个元素必须为零。
d<type>稠密数组，包含三对角线性 系统的主对角线。
du<type>稠密数组，包含三对角线性系 统的上对角线。每个上对角线的最后 一个元素必须为零。
B一个维度为
(ldb, n)的右侧 <type>稠密数组。ldb矩阵
B的主维度。pBuffer由用户分配的缓冲区，其大小由
gtsv2_nopivot_bufferSizeExt决定。输出
B一个维度为
(ldb, n)的<type> 稠密解数组
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.4. 批处理三对角线求解(Batched Tridiagonal Solve)
本节讨论了批处理三对角线线性求解的不同算法。
11.4.1. mcsparse<t>gtsv2StridedBatch_bufferSizeExt()
mcsparseStatus_t
mcsparseSgtsv2StridedBatch_bufferSizeExt(mcsparseHandle_t handle,
int m,
const float* dl,
const float* d,
const float* du,
const float* x,
int batchCount,
int batchStride,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseDgtsv2StridedBatch_bufferSizeExt(mcsparseHandle_t handle,
int m,
const double* dl,
const double* d,
const double* du,
const double* x,
int batchCount,
int batchStride,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseCgtsv2StridedBatch_bufferSizeExt(mcsparseHandle_t handle,
int m,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
const mcComplex* x,
int batchCount,
int batchStride,
size_t* bufferSizeInBytes)
mcsparseStatus_t
mcsparseZgtsv2StridedBatch_bufferSizeExt(mcsparseHandle_t handle,
int m,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
const mcDoubleComplex* x,
int batchCount,
int batchStride,
size_t* bufferSizeInBytes)
此函数返回用于 gtsv2StridedBatch 的缓冲区大小，此函数计算 i= 0,…,batchCount 之间的多个三对角线线性系统的解。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
n线性系统的规模大小。 (必须 >= 3)。
dl<type> 稠密数组，包含三对角线性系 统的下对角线。
d<type> 稠密数组，包含三对角线性系 统的主对角线。
du<type> 稠密数组，包含三对角线性系 统的上对角线。
x一个包含三对角线性系统右侧 项的<type>稠密数组。
batchCount要求解的系统数量。
batchStride将每个系统的向量分开的步幅 (元素的数量)(必须至少为m)。
输出
pBufferSizeInBytes在
gtsv2StridedBatch中使用的缓冲区的 字节数。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.4.2. mcsparse<t>gtsv2StridedBatch()
mcsparseStatus_t
mcsparseSgtsv2StridedBatch(mcsparseHandle_t handle,
int m,
const float* dl,
const float* d,
const float* du,
float* x,
int batchCount,
int batchStride,
void* pBuffer)
mcsparseStatus_t
mcsparseDgtsv2StridedBatch(mcsparseHandle_t handle,
int m,
const double* dl,
const double* d,
const double* du,
double* x,
int batchCount,
int batchStride,
void* pBuffer)
mcsparseStatus_t
mcsparseCgtsv2StridedBatch(mcsparseHandle_t handle,
int m,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
mcComplex* x,
int batchCount,
int batchStride,
void* pBuffer)
mcsparseStatus_t
mcsparseZgtsv2StridedBatch(mcsparseHandle_t handle,
int m,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
mcDoubleComplex* x,
int batchCount,
int batchStride,
void* pBuffer)
此函数计算 i=0,…,batchCount 的多个三对角线线性系统的解。
每个三对角线线性系统的系数矩阵 A 是由其下对角线(dl)、主对角线(d)和上对角线(du)对应的三个向量定义的；右侧的项存储在稠密矩阵 X 中。
请注意，在退出时，解 Y 会覆盖右侧矩阵 X。
假设不同的矩阵具有相同的大小，并且以固定的 batchStride 存储在内存中。
该程序不执行任何主元素选取操作，而是使用循环归约(Cyclic Reduction,CR)和并行循环归约(Parallel Cyclic Reduction,PCR)这两种算法的组合来求解。
当 m 是2次幂时，它可以实现更好的性能。
此函数需要一个由 gtsv2_nopivot_bufferSizeExt() 返回的缓冲区大小。
pBuffer 的地址必须是128字节的倍数。
如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE。
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
n线性系统的规模大小。 (必须 >= 3)。
dl<type> 稠密数组，包含三对角线性系 统的下对角线。
d<type> 稠密数组，包含三对角线性系 统的主对角线。
du<type> 稠密数组，包含三对角线性系 统的上对角线。
x<type> 一个包含三对角线性系统右侧 项的稠密数组。
batchCount要求解的系统数量。
batchStride将每个系统的向量分开的步幅 (元素的数量)(必须至少为m)。
pBuffer由用户分配的缓冲区，大小由
gtsv2StridedBatch_bufferSizeExt返回。输出
x<type> 稠密数组，包含三对角线性系 统的解。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.4.3. mcsparse<t>gtsvInterleavedBatch()
mcsparseStatus_t
mcsparseSgtsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const float* dl,
const float* d,
const float* du,
const float* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseDgtsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const double* dl,
const double* d,
const double* du,
const double* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseCgtsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
const mcComplex* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseZgtsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
const mcDoubleComplex* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseSgtsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
float* dl,
float* d,
float* du,
float* x,
int batchCount,
void* pBuffer)
mcsparseStatus_t
mcsparseDgtsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
double* dl,
double* d,
double* du,
double* x,
int batchCount,
void* pBuffer)
mcsparseStatus_t
mcsparseCgtsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
mcComplex* dl,
mcComplex* d,
mcComplex* du,
mcComplex* x,
int batchCount,
void* pBuffer)
mcsparseStatus_t
mcsparseZgtsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
mcDoubleComplex* dl,
mcDoubleComplex* d,
mcDoubleComplex* du,
mcDoubleComplex* x,
int batchCount,
void* pBuffer)
此函数执行 csrsm2 的分析阶段，用于稀疏三角线性系统。
此函数计算 i=0,…,batchCount 的多个三对角线线性系统的解。
这些三对角线性系统的系数矩阵 A 由三个向量定义，分别对应于它的下对角线( dl )、主对角线( d )和上对角线( du )；右侧的值存储在稠密矩阵 B 中。
请注意，在退出时，解 X 会覆盖右侧矩阵 B。
假设 A 的大小为 m 且基于1索引, dl, d 和 du 由以下公式定义：
dl(i) := A(i, i-1)，其中 i=1,2,...,m。
dl 的第一个元素超出边界 (dl(1) := A(1,0))，所以 dl(1) = 0。
对于
i=1,2,...,m有d(i) = A(i, i)。对于
i=1,2,...,m有du(i) = A(i, i+1)。
du 的最后一个元素超出边界 (du(m) := A(m,m+1))，所以 du(m) = 0。
数据布局与 gtsvStridedBatch 不同，后者将所有矩阵按顺序聚合在一起。
相反， gtsvInterleavedBatch 以连续的方式收集相同元素的不同矩阵。
如果将 dl 视为大小为 m-by-batchCount 的二维数组，则 dl(:,j) 存储第 j 个矩阵。
gtsvStridedBatch 使用列主序，而 gtsvInterleavedBatch 使用行主序。
该程序提供了三种不同的算法，由参数 algo 选择。
第一种算法是由 Barcelona Supercomputing Center 提供的 mcThomas 算法。
第二种算法是带有部分主元选取的 LU 分解算法，最后一种算法是 QR 分解算法。
从稳定性的角度来看， mcThomas 算法在数值上不稳定，因为它没有进行主元选取。
部分主元选取的 LU 分解算法和 QR 分解算法是稳定的。
从性能的角度来看，带有部分主元选取的 LU 分解算法和 QR 分解算法比 mcThomas 算法慢大约10%到20%。
此函数需要一个由 gtsvInterleavedBatch_bufferSizeExt() 返回的缓冲区大小。
pBuffer 的地址必须是128字节的倍数。如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE。
如果用户准备了聚合格式，可以使用 mcblasXgeam 来获取交错格式。
然而，这种转换所需要的时间与求解器本身相当。
为了达到最佳性能，用户必须明确准备交错格式。
此函数需要内部分配的临时额外存储空间。
如果流式有序内存分配器可用，则该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
algoalgo = 0: mcThomas(不稳定的算法); algo = 1: 带主元的LU分解算法(稳定算法) algo = 2: QR分解算法(稳定算法)。
m线性系统的大小
dl<type> 稠密数组，包含三对角线性系 统的下对角线。 每个下对角线的第一 个元素必须为零。
d<type> 稠密数组，包含三对角线性系 统的主对角线。
du<type> 稠密数组，包含三对角线性系 统的上对角线。每个上对角线的最后 一个元素必须为零。
x维度为
(batchCount, n)的 右侧<type>稠密数组。pBuffer由用户分配的缓冲区，大小由
gtsv2StridedBatch_bufferSizeExt返回。输出
x维度为
(batchCount, n)的<type>稠密解数组。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。
11.5. 批处理五对角线方程求解
本节讨论了批处理五对角线方程求解的不同算法。
11.5.1. mcsparse<t>gpsvInterleavedBatch()
mcsparseStatus_t
mcsparseSgpsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const float* ds,
const float* dl,
const float* d,
const float* du,
const float* dw,
const float* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseDgpsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const double* ds,
const double* dl,
const double* d,
const double* du,
const double* dw,
const double* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseCgpsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const mcComplex* ds,
const mcComplex* dl,
const mcComplex* d,
const mcComplex* du,
const mcComplex* dw,
const mcComplex* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseZgpsvInterleavedBatch_bufferSizeExt(mcsparseHandle_t handle,
int algo,
int m,
const mcDoubleComplex* ds,
const mcDoubleComplex* dl,
const mcDoubleComplex* d,
const mcDoubleComplex* du,
const mcDoubleComplex* dw,
const mcDoubleComplex* x,
int batchCount,
size_t* BufferSize)
mcsparseStatus_t
mcsparseSgpsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
float* ds,
float* dl,
float* d,
float* du,
float* dw,
float* x,
int batchCount,
void* pBuffer)
mcsparseStatus_t
mcsparseDgpsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
double* ds,
double* dl,
double* d,
double* du,
double* dw,
double* x,
int batchCount,
void* pBuffer)
mcsparseStatus_t
mcsparseCgpsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
mcComplex* ds,
mcComplex* dl,
mcComplex* d,
mcComplex* du,
mcComplex* dw,
mcComplex* x,
int batchCount,
void* pBuffer)
mcsparseStatus_t
mcsparseZgpsvInterleavedBatch(mcsparseHandle_t handle,
int algo,
int m,
mcDoubleComplex* ds,
mcDoubleComplex* dl,
mcDoubleComplex* d,
mcDoubleComplex* du,
mcDoubleComplex* dw,
mcDoubleComplex* x,
int batchCount,
void* pBuffer)
此函数计算多个五对角线性系统的解，对于 i=0,…, batchCount。
这些五对角线性系统的系数矩阵 A 由五个向量定义，分别对应于它的下对角线( ds, dl )、主对角线( d )和上对角线( du, dw )；右侧的值存储在稠密矩阵 B 中。
请注意，解 X 在退出时会覆盖右侧矩阵 B。
假设 A 的大小为 m，从1开始计数， ds， dl， d， du 和 dw 由以下公式定义：
对于
i=1,2,...,m，ds(i) := A(i, i-2)
ds 的前两个元素超出边界 (ds(1) := A(1,-1)， ds(2) := A(2,0))，因此 ds(1) = 0 和 ds(2) = 0。
对于
i=1,2,...,m，dl(i) := A(i, i-1)
dl 的第一个元素超出边界 (dl(1) := A(1,0))，因此 dl(1) = 0 。
对于
i=1,2,...,m，d(i) = A(i,i)对于
i=1,2,...,m，du(i) = A(i,i+1)
du 的最后一个元素超出边界 (du(m) := A(m,m+1))，因此 du(m) = 0 。
对于
i=1,2,...,m，dw(i) = A(i,i+2)
dw 的最后两个元素超出边界 (dw(m-1) := A(m-1,m+1)， dw(m) := A(m,m+2))，因此 dw(m-1) = 0 和 dw(m) = 0。
数据布局与 gtsvStridedBatch 相同。
该程序在数值上是稳定的，因为它使用QR分解来求解线性系统。
此函数需要一个由 gtsvInterleavedBatch_bufferSizeExt() 返回的缓冲区大小。
pBuffer 的地址必须是128字节的倍数。
如果不是，将返回 MCSPARSE_STATUS_INVALID_VALUE。
如果用户准备了聚合格式，可以使用 mcblasXgeam 来获取交错格式。
然而，这种转换所需要的时间与求解器本身相当。
为了达到最佳性能，用户必须明确准备交错格式。
如果 pBuffer != NULL，此函数支持以下特性：
该例程不需要额外的存储空间。
该例程支持异步执行。
输入
handle处理mcSPARSE库上下文的句柄。
algo仅支持 algo = 0(QR)。
m线性系统的大小
ds<type> 稠密数组，包含五对角线线性系统 的下对角线(距离主对角线为2的元素)。 第一个元素和第二个元素必须为零。
dl<type> 稠密数组，包含五对角线线性系统 的下对角线(距离主对角线为1的元素)。 第一个元素必须为零。
d<type> 稠密数组，包含五对角线线性系统 的主对角线。
du<type> 稠密数组，包含五对角线线性系统 的上对角线(距离主对角线为1的元素)。 最后一个元素必须为零。
dw<type> 稠密数组，包含五对角线线性系统 的上对角线(距离主对角线为2的元素)。 最后两个元素必须为零。
x维度为
(batchCount, n)的 的右侧<type>稠密数组。pBuffer由用户分配的缓冲区，大小由
gtsv2StridedBatch_bufferSizeExt返回。输出
x维度为
(batchCount, n)的<type>稠密解数组。
有关返回状态的描述，请参见 4.2 mcsparseStatus_t。