muBLAS API 参考

函数

函数 mublasIsamax

mublasStatus mublasIsamax(
    mublasHandle_t handle,
    mublas_int n,
    const float * x,
    mublas_int incx,
    mublas_int * result
)

函数 mublasIdamax

mublasStatus mublasIdamax(
    mublasHandle_t handle,
    mublas_int n,
    const double * x,
    mublas_int incx,
    mublas_int * result
)

函数 mublasIzamax

mublasStatus mublasIzamax(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * x,
    mublas_int incx,
    mublas_int * result
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x中元素的数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定y元素的增量。
result 设备指针或主机指针，用于存储amax索引。如果n, incx <= 0，则返回为0.0。

amax查找向量x中最大绝对值元素的第一个索引。向量

函数 mublasIcamax

mublasStatus mublasIcamax(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * x,
    mublas_int incx,
    mublas_int * result
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] 每个向量x_i中的元素数量
x 设备数组，存储每个向量x_i的设备指针。
incx [mublas_int] 指定每个x_i元素的增量。incx必须大于0。
batch_count [mublas_int] 批次中的实例数量，必须大于0。
result 设备或主机数组的指针，用于存储batch_count大小的结果。如果n, incx<=0，则返回为0。

amax_batched在批次中查找每个向量x_i中最大绝对值元素的第一个索引，对于i = 1, ..., batch_count。

函数 mublasIsamin

mublasStatus mublasIsamin(
    mublasHandle_t handle,
    mublas_int n,
    const float * x,
    mublas_int incx,
    mublas_int * result
)

函数 mublasIdamin

mublasStatus mublasIdamin(
    mublasHandle_t handle,
    mublas_int n,
    const double * x,
    mublas_int incx,
    mublas_int * result
)

函数 mublasIzamin

mublasStatus mublasIzamin(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * x,
    mublas_int incx,
    mublas_int * result
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x中的元素数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定y元素的增量。
result 设备指针或主机指针，用于存储amin索引。如果n, incx<=0，则返回为0.0。

amin查找向量x中最小绝对值元素的第一个索引。向量

函数 mublasIcamin

mublasStatus mublasIcamin(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * x,
    mublas_int incx,
    mublas_int * result
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] 每个向量x_i中的元素数量
x 设备数组，存储每个向量x_i的设备指针。
incx [mublas_int] 指定每个x_i元素的增量。incx必须大于0。
batch_count [mublas_int] 批次中的实例数量，必须大于0。
result 设备或主机指针数组，用于存储batch_count大小的结果。如果n, incx<=0，则返回为0。

amin_batched在批次中查找每个向量x_i中最小绝对值元素的第一个索引，对于i = 1, ..., batch_count。

函数 mublasSasum

mublasStatus mublasSasum(
    mublasHandle_t handle,
    mublas_int n,
    const float * x,
    mublas_int incx,
    float * result
)

函数 mublasDasum

mublasStatus mublasDasum(
    mublasHandle_t handle,
    mublas_int n,
    const double * x,
    mublas_int incx,
    double * result
)

函数 mublasDzasum

mublasStatus mublasDzasum(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * x,
    mublas_int incx,
    double * result
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x和y中的元素数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。incx必须大于0。
result 设备指针或主机指针，用于存储asum乘积。如果n <= 0，则返回为0.0。

asum计算实向量x元素的绝对值之和，或者如果x是复向量，则计算实部和虚部元素的绝对值之和

函数 mublasScasum

mublasStatus mublasScasum(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * x,
    mublas_int incx,
    float * result
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x和y中的元素数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。incx必须大于0。
result 设备指针或主机指针，用于存储asum乘积。如果n <= 0，则返回为0.0。

asum计算实向量x元素的绝对值之和，或者如果x是复向量，则计算实部和虚部元素的绝对值之和

函数 mublasSaxpy

mublasStatus mublasSaxpy(
    mublasHandle_t handle,
    mublas_int n,
    const float * alpha,
    const float * x,
    mublas_int incx,
    float * y,
    mublas_int incy
)

函数 mublasDaxpy

mublasStatus mublasDaxpy(
    mublasHandle_t handle,
    mublas_int n,
    const double * alpha,
    const double * x,
    mublas_int incx,
    double * y,
    mublas_int incy
)

函数 mublasZaxpy

mublasStatus mublasZaxpy(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * x,
    mublas_int incx,
    muDoubleComplex * y,
    mublas_int incy
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x和y中的元素数量。
alpha 设备指针或主机指针，指定标量alpha。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。
y 设备指针，存储向量y。
incy [mublas_int] 指定y元素的增量。

axpy计算常数alpha乘以向量x，加上向量y

\mathbf{y} := \alpha \cdot \mathbf{x} + \mathbf{y}

函数 mublasCaxpy

mublasStatus mublasCaxpy(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * x,
    mublas_int incx,
    muComplex * y,
    mublas_int incy
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x和y中的元素数量。
alpha 设备指针或主机指针，指定标量alpha。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。
y 设备指针，存储向量y。
incy [mublas_int] 指定y元素的增量。

axpy计算常数alpha乘以向量x，加上向量y

\mathbf{y} := \alpha \cdot \mathbf{x} + \mathbf{y}

函数 mublasCcopy

mublasStatus mublasCcopy(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * x,
    mublas_int incx,
    muComplex * y,
    mublas_int incy
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] 从x复制到y的元素数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。
y 设备指针，存储向量y。
incy [mublas_int] 指定y元素的增量。

copy将每个元素x[i]复制到y[i]，对于i = 1, \dots, n。

\mathbf{y} := \mathbf{x}

函数 mublasScopy

mublasStatus mublasScopy(
    mublasHandle_t handle,
    mublas_int n,
    const float * x,
    mublas_int incx,
    float * y,
    mublas_int incy
)

函数 mublasDcopy

mublasStatus mublasDcopy(
    mublasHandle_t handle,
    mublas_int n,
    const double * x,
    mublas_int incx,
    double * y,
    mublas_int incy
)

函数 mublasZcopy

mublasStatus mublasZcopy(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * x,
    mublas_int incx,
    muDoubleComplex * y,
    mublas_int incy
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] 从x复制到y的元素数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。
y 设备指针，存储向量y。
incy [mublas_int] 指定y元素的增量。

copy将每个元素x[i]复制到y[i]，对于i = 1 , ... , n

\mathbf{y} := \mathbf{x}

函数 mublasSdot

mublasStatus mublasSdot(
    mublasHandle_t handle,
    mublas_int n,
    const float * x,
    mublas_int incx,
    const float * y,
    mublas_int incy,
    float * result
)

函数 mublasZdotc

mublasStatus mublasZdotc(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * x,
    mublas_int incx,
    const muDoubleComplex * y,
    mublas_int incy,
    muDoubleComplex * result
)

函数 mublasDdot

mublasStatus mublasDdot(
    mublasHandle_t handle,
    mublas_int n,
    const double * x,
    mublas_int incx,
    const double * y,
    mublas_int incy,
    double * result
)

函数 mublasZdotu

mublasStatus mublasZdotu(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * x,
    mublas_int incx,
    const muDoubleComplex * y,
    mublas_int incy,
    muDoubleComplex * result
)

BLAS 一级 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x和y中的元素数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。
y 设备指针，存储向量y。
incy [mublas_int] 指定y元素的增量。
result 设备指针或主机指针，用于存储点积。如果 $n \leq 0$ ，则返回为0.0。

**dot(u)**执行向量x和y的点积：

\text{result} = \mathbf{x} \cdot \mathbf{y}

dotc执行复向量x的共轭和复向量y的点积：

\text{result} = \overline{\mathbf{x}} \cdot \mathbf{y}

函数 mublasCdotu

mublasStatus mublasCdotu(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * x,
    mublas_int incx,
    const muComplex * y,
    mublas_int incy,
    muComplex * result
)

BLAS 一级 API。

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x和y中的元素数量。
x 设备指针，存储向量x。
incx [mublas_int] 指定x元素的增量。
y 设备指针，存储向量y。
incy [mublas_int] 指定y元素的增量。
result 设备指针或主机指针，用于存储点积。如果 $n \leq 0$ ，则返回为0.0。

**dot(u)**执行向量x和y的点积：

\text{result} = \mathbf{x} \cdot \mathbf{y}

dotc执行复向量x的共轭和复向量y的点积：

\text{result} = \overline{\mathbf{x}} \cdot \mathbf{y}

函数 mublasCgbmv

mublasStatus mublasCgbmv(
    mublasHandle_t handle,
    mublasOperation_t trans,
    mublas_int m,
    mublas_int n,
    mublas_int kl,
    mublas_int ku,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    const muComplex * x,
    mublas_int incx,
    const muComplex * beta,
    muComplex * y,
    mublas_int incy
)

BLAS 二级 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
trans: [mublasOperation_t] 指示矩阵 $A$ 是否转置（共轭）。
m: [mublas_int] 矩阵 $A$ 的行数。
n: [mublas_int] 矩阵 $A$ 的列数。
kl: [mublas_int] $A$ 的次对角线数量。
ku: [mublas_int] $A$ 的超对角线数量。
alpha: 设备指针或主机指针，指定标量 $\alpha$ 。
A: 设备指针，存储带状矩阵 $A$ 。矩阵包含前导 $(kl + ku + 1)$ 乘以 $n$ 部分的系数。主对角线位于行 $(ku + 1)$ ，第一超对角线位于行 $ku$ 的右侧，第一次对角线位于行 $ku + 2$ 的左侧。结构在次/超对角线上下传播。
lda: [mublas_int] $A$ 的前导维度。必须 $\geq (kl + ku + 1)$ 。
x: 设备指针，存储向量 $\mathbf{x}$ 。
incx: [mublas_int] 指定 $\mathbf{x}$ 元素的增量。
beta: 设备指针或主机指针，指定标量 $\beta$ 。
y: 设备指针，存储向量 $\mathbf{y}$ 。
incy: [mublas_int] 指定 $\mathbf{y}$ 元素的增量。

gbmv函数执行以下矩阵-向量操作之一：

\mathbf{y} := \alpha \cdot A \cdot \mathbf{x} + \beta \cdot \mathbf{y}, \quad \text{or} \quad \mathbf{y} := \alpha \cdot A^T \cdot \mathbf{x} + \beta \cdot \mathbf{y}, \quad \text{or} \quad \mathbf{y} := \alpha \cdot A^H \cdot \mathbf{x} + \beta \cdot \mathbf{y},

其中：

$\alpha$ 和 $\beta$ 是标量。
$\mathbf{x}$ 和 $\mathbf{y}$ 是向量。
$A$ 是一个 $m \times n$ 带状矩阵，有 $k_l$ 次对角线和 $k_u$ 超对角线。

示例

例如，当 $m = n = 7$ ， $ku = 2$ ，和 $kl = 2$ 时：

矩阵 $A$ ：

\begin{bmatrix} 1 & 2 & 3 & 0 & 0 & 0 & 0 \\ 0 & 3 & 3 & 3 & 3 & 3 & 4 \\ 1 & 2 & 3 & 0 & 0 & 0 & 0 \\ 2 & 2 & 2 & 2 & 2 & 2 & 5 \\ 4 & 1 & 2 & 3 & 0 & 0 & 0 \\ 5 & 4 & 1 & 2 & 3 & 0 & 0 \\ 0 & 0 & 0 & 5 & 4 & 1 & 2 \end{bmatrix}

矩阵将以压缩格式存储，考虑次和超对角线。不对应数据的空元素将不会被引用。

函数 mublasSgbmv

mublasStatus mublasSgbmv(
    mublasHandle_t handle,
    mublasOperation_t trans,
    mublas_int m,
    mublas_int n,
    mublas_int kl,
    mublas_int ku,
    const float * alpha,
    const float * A,
    mublas_int lda,
    const float * x,
    mublas_int incx,
    const float * beta,
    float * y,
    mublas_int incy
)

函数 mublasDgbmv

mublasStatus mublasDgbmv(
    mublasHandle_t handle,
    mublasOperation_t trans,
    mublas_int m,
    mublas_int n,
    mublas_int kl,
    mublas_int ku,
    const double * alpha,
    const double * A,
    mublas_int lda,
    const double * x,
    mublas_int incx,
    const double * beta,
    double * y,
    mublas_int incy
)

函数 mublasZgbmv

mublasStatus mublasZgbmv(
    mublasHandle_t handle,
    mublasOperation_t trans,
    mublas_int m,
    mublas_int n,
    mublas_int kl,
    mublas_int ku,
    const muDoubleComplex * alpha,
    const muDoubleComplex * A,
    mublas_int lda,
    const muDoubleComplex * x,
    mublas_int incx,
    const muDoubleComplex * beta,
    muDoubleComplex * y,
    mublas_int incy
)

BLAS 二级 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
trans: [mublasOperation_t] 指示矩阵 $A$ 是否转置（共轭）。
m: [mublas_int] 矩阵 $A$ 的行数。
n: [mublas_int] 矩阵 $A$ 的列数。
kl: [mublas_int] $A$ 的次对角线数量。
ku: [mublas_int] $A$ 的超对角线数量。
alpha: 设备指针或主机指针，指定标量 $\alpha$ 。
A: 设备指针，存储带状矩阵 $A$ 。矩阵包含前导 $(kl + ku + 1) \times n$ 部分的系数。主对角线位于行 $(ku + 1)$ ，第一超对角线位于行 $ku$ 的右侧，第一

函数 mublasZher2k

mublasStatus mublasZher2k(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublas_int n,
    mublas_int k,
    const muDoubleComplex * alpha,
    const muDoubleComplex * A,
    mublas_int lda,
    const muDoubleComplex * B,
    mublas_int ldb,
    const double * beta,
    muDoubleComplex * C,
    mublas_int ldc
)

BLAS Level 3 API

handle: [mublasHandle_t] mublas库上下文队列的句柄。
uplo: [mublasFillMode_t]
- MUBLAS_FILL_MODE_UPPER: $C$ 是一个上三角矩阵。
- MUBLAS_FILL_MODE_LOWER: $C$ 是一个下三角矩阵。
trans: [mublasOperation_t]
- MUBLAS_OP_C: $\text{op}(A) = A^H$ , $\text{op}(B) = B^H$
- MUBLAS_OP_N: $\text{op}(A) = A$ , $\text{op}(B) = B$
n: [mublas_int] 矩阵 $C$ 的行数和列数。必须满足 $n \geq 0$ 。
k: [mublas_int] $\text{op}(A)$ 的列数。必须满足 $k \geq 0$ 。
alpha: 标量 $\alpha$ 。当 $\alpha = 0$ 时，不引用 $A$ ，且在进入前不需要设置 $A$ 。
A: 存储在GPU上的矩阵 $A$ $A$ 的指针。矩阵尺寸为：
- $(\text{lda}, k)$ 当 $trans = MUBLAS\_OP\_N$ 时，
- $(\text{lda}, n)$ 当 $trans = MUBLAS\_OP\_C$ 时。
- 仅访问上/下三角部分。
lda: [mublas_int] $A$ $A$ 的领先维度。
- 如果 $trans = MUBLAS\_OP\_N$ ，则 $\text{lda} \geq \max(1, n)$ 。
- 否则， $\text{lda} \geq \max(1, k)$ 。
B: 存储在GPU上的矩阵 $B$ $B$ 的指针。矩阵尺寸为：
- $(\text{ldb}, k)$ 当 $trans = MUBLAS\_OP\_N$ 时，
- $(\text{ldb}, n)$ 当 $trans = MUBLAS\_OP\_C$ 时。
- 仅访问上/下三角部分。
ldb: [mublas_int] $B$ $B$ 的领先维度。
- 如果 $trans = MUBLAS\_OP\_N$ ，则 $\text{ldb} \geq \max(1, n)$ 。
- 否则， $\text{ldb} \geq \max(1, k)$ 。
beta: 标量 $\beta$ 。当 $\beta = 0$ 时，不需要在进入前设置 $C$ 。
C: 存储在GPU上的矩阵 $C$ 的指针。对角线元素的虚部不访问，并假定为0，除非执行快速返回。
ldc: [mublas_int] $C$ 的领先维度。必须满足 $\text{ldc} \geq \max(1, n)$ 。

操作

her2k 函数执行矩阵-矩阵操作的Hermitian秩-2k更新：

C := \alpha , \text{op}(A) , \text{op}(B)^H + \overline{\alpha} , \text{op}(B) , \text{op}(A)^H + \beta C

其中：

$\alpha$ 和 $\beta$ 是标量。
$\text{op}(A)$ 和 $\text{op}(B)$ 是 $n \times k$ 矩阵。
$C$ 是一个 $n \times n$ Hermitian 矩阵。
如果 $trans = MUBLAS\_OP\_N$ ，则 $\text{op}(A) = A$ 且 $\text{op}(B) = B$ 。
如果 $trans = MUBLAS\_OP\_C$ ，则 $\text{op}(A) = A^H$ 且 $\text{op}(B) = B^H$ 。

函数 mublasCherk

mublasStatus mublasCherk(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const float * alpha,
    const muComplex * A,
    mublas_int lda,
    const float * beta,
    muComplex * C,
    mublas_int ldc
)

函数 mublasZherk

mublasStatus mublasZherk(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const double * alpha,
    const muDoubleComplex * A,
    mublas_int lda,
    const double * beta,
    muDoubleComplex * C,
    mublas_int ldc
)

BLAS Level 3 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
uplo: [mublasFillMode_t]
- MUBLAS_FILL_MODE_UPPER: $C$ 是一个上三角矩阵。
- MUBLAS_FILL_MODE_LOWER: $C$ 是一个下三角矩阵。
transA: [mublasOperation_t]
- MUBLAS_OP_C: $\text{op}(A) = A^H$
- MUBLAS_OP_N: $\text{op}(A) = A$
n: [mublas_int] 矩阵 $C$ 的行数和列数。必须满足 $n \geq 0$ 。
k: [mublas_int] $\text{op}(A)$ 的列数。必须满足 $k \geq 0$ 。
alpha: 标量 $\alpha$ 。当 $\alpha = 0$ 时，不引用 $A$ ，且在进入前不需要设置 $A$ 。
A: 存储在GPU上的矩阵 $A$ $A$ 的指针。矩阵尺寸为：
- $(\text{lda}, k)$ 当 $transA = MUBLAS\_OP\_N$ 时，
- $(\text{lda}, n)$ 当 $transA = MUBLAS\_OP\_C$ 时。
- 仅访问上/下三角部分。
lda: [mublas_int] $A$ $A$ 的领先维度。
- 如果 $transA = MUBLAS\_OP\_N$ ，则 $\text{lda} \geq \max(1, n)$ 。
- 否则， $\text{lda} \geq \max(1, k)$ 。
beta: 标量 $\beta$ 。当 $\beta = 0$ 时，不需要在进入前设置 $C$ 。
C: 存储在GPU上的矩阵 $C$ 的指针。对角线元素的虚部不访问，并假定为0，除非执行快速返回。
ldc: [mublas_int] $C$ 的领先维度。必须满足 $\text{ldc} \geq \max(1, n)$ 。

操作

herk 函数执行矩阵-矩阵操作的Hermitian秩-k更新：

C := \alpha , \text{op}(A) , \text{op}(A)^H + \beta C

其中：

$\alpha$ 和 $\beta$ 是标量。
$\text{op}(A)$ 是一个 $n \times k$ 矩阵。
$C$ 是一个 $n \times n$ Hermitian 矩阵，存储为上三角或下三角。
如果 $trans = MUBLAS\_OP\_N$ ，则 $\text{op}(A) = A$ 且 $A$ 是 $n \times k$ 。
如果 $trans = MUBLAS\_OP\_C$ ，则 $\text{op}(A) = A^H$ 且 $A$ 是 $k \times n$ 。

函数 mublasCherkStridedBatched

mublasStatus mublasCherkStridedBatched(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const float * alpha,
    const muComplex * A,
    mublas_int lda,
    mublas_stride stride_A,
    const float * beta,
    muComplex * C,
    mublas_int ldc,
    mublas_stride stride_C,
    mublas_int batch_count
)

BLAS Level 3 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
uplo: [mublasFillMode_t]
- MUBLAS_FILL_MODE_UPPER: $C_i$ 是一个上三角矩阵。
- MUBLAS_FILL_MODE_LOWER: $C_i$ 是一个下三角矩阵。
transA: [mublasOperation_t]
- MUBLAS_OP_C: $\text{op}(A) = A^H$
- MUBLAS_OP_N: $\text{op}(A) = A$
n: [mublas_int] 矩阵 $C_i$ 的行数和列数。必须满足 $n \geq 0$ 。
k: [mublas_int] $\text{op}(A)$ 的列数。必须满足 $k \geq 0$ 。
alpha: 标量 $\alpha$ 。当 $\alpha = 0$ 时，不引用 $A$ ，且在进入前不需要设置 $A$ 。
A: 设备指针，指向GPU上的第一个矩阵 $A\_1$ $A_1$ 。矩阵尺寸为：
- $(\text{lda}, k)$ 当 $transA = MUBLAS\_OP\_N$ 。
- $(\text{lda}, n)$ 当 $transA = MUBLAS\_OP\_C$ 。
lda: [mublas_int] $A_i$ $A_{i}$ 的领先维度。
- 如果 $transA = MUBLAS\_OP\_N$ ，则 $\text{lda} \geq \max(1, n)$ 。
- 否则， $\text{lda} \geq \max(1, k)$ 。
stride_A: [mublas_stride] 从一个矩阵 ( $A_i$ ) 的开始到下一个矩阵 ( $A_{i+1}$ ) 的步长。
beta: 标量 $\beta$ 。当 $\beta = 0$ 时，不需要在进入前设置 $C$ 。
C: 设备指针，指向GPU上的第一个矩阵 $C_1$ 。对角线元素的虚部不访问，并假定为0，除非执行快速返回。
ldc: [mublas_int] $C$ 的领先维度。必须满足 $\text{ldc} \geq \max(1, n)$ 。
stride_C: [mublas_stride] 从一个矩阵 ( $C_i$ ) 的开始到下一个矩阵 ( $C_{i+1}$ ) 的步长。
batch_count: [mublas_int] 批次中的实例数量。

操作

herk_strided_batched 函数执行一批矩阵-矩阵操作的Hermitian秩-k更新：

C_i := \alpha , \text{op}(A_i) , \text{op}(A_i)^H + \beta C_i

其中：

$\alpha$ 和 $\beta$ 是标量。
$\text{op}(A_i)$ 是一个 $n \times k$ 矩阵。
$C_i$ 是一个 $n \times n$ Hermitian 矩阵。
如果 $transA = MUBLAS\_OP\_N$ ，则 $\text{op}(A_i) = A_i$ 。
如果 $transA = MUBLAS\_OP\_C$ ，则 $\text{op}(A_i) = A_i^H$ 。

函数 mublasChpmv

mublasStatus mublasChpmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * AP,
    const muComplex * x,
    mublas_int incx,
    const muComplex * beta,
    muComplex * y,
    mublas_int incy
)

函数 mublasZhpmv

mublasStatus mublasZhpmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * AP,
    const muDoubleComplex * x,
    mublas_int incx,
    const muDoubleComplex * beta,
    muDoubleComplex * y,
    mublas_int incy
)

BLAS Level 2 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
uplo: [mublasFillMode_t]
- MUBLAS_FILL_MODE_UPPER: Hermitian矩阵 $A$ 的上三角部分在 $AP$ 中提供。
- MUBLAS_FILL_MODE_LOWER: Hermitian矩阵 $A$ 的下三角部分在 $AP$ 中提供。
n: [mublas_int] 矩阵 $A$ 的阶数。必须满足 $n \geq 0$ 。
alpha: 设备指针或主机指针，指向标量 $\alpha$ 。
AP: 设备指针，存储指定三角部分的 Hermitian 矩阵 $A$ $A$ 的打包版本。大小至少为 $\frac{n(n + 1)}{2}$ $\frac{n ( n + 1 )}{2}$ 。如果 $uplo = MUBLAS\_FILL\_MODE\_UPPER$ $u pl o = M U B L A S_F I LL_MO D E_U PPER$ ，则提供 $A$ $A$ 的上三角部分。矩阵打包如下：
- $AP(0) = A(0,0)$ ，
- $AP(1) = A(0,1)$ ，
- $AP(2) = A(1,1)$ ，依此类推。
- 如果 $uplo = MUBLAS\_FILL\_MODE\_LOWER$ ，则提供 $A$ 的下三角部分。矩阵打包如下：
- $AP(0) = A(0,0)$ ，
- $AP(1) = A(1,0)$ ，
- $AP(2) = A(2,1)$ ，依此类推。
- 注意：对角线元素的虚部不访问，并假定为0。
x: 设备指针，存储向量 $x$ 。
incx: [mublas_int] 指定 $x$ 元素的增量。
beta: 设备指针或主机指针，指向标量 $\beta$ 。
y: 设备指针，存储向量 $y$ 。
incy: [mublas_int] 指定 $y$ 元素的增量。

操作

hpmv 函数执行矩阵-向量操作：

y := \alpha A x + \beta y

其中：

$\alpha$ 和 $\beta$ 是标量。
$A$ 是一个 $n \times n$ Hermitian 矩阵，以打包形式提供。
$x$ 和 $y$ 是 $n$ 元素向量。

函数 mublasChpr

mublasStatus mublasChpr(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const float * alpha,
    const muComplex * x,
    mublas_int incx,
    muComplex * AP
)

函数 mublasZhpr

mublasStatus mublasZhpr(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const double * alpha,
    const muDoubleComplex * x,
    mublas_int incx,
    muDoubleComplex * AP
)

BLAS Level 2 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
uplo: [mublasFillMode_t] 指定 $A$ $A$ 的上三角或下三角部分在 $AP$ $A P$ 中提供。
- MUBLAS_FILL_MODE_UPPER: $A$ 的上三角部分在 $AP$ 中提供。
- MUBLAS_FILL_MODE_LOWER: $A$ 的下三角部分在 $AP$ 中提供。
n: [mublas_int] 矩阵 $A$ 的行数和列数。必须至少为0。
alpha: 设备或主机指针，指向标量 $\alpha$ 。
x: 设备指针，存储向量 $x$ 。
incx: [mublas_int] 指定 $x$ 元素的增量。
AP: 设备指针，存储指定三角部分的Hermitian矩阵 $A$ $A$ 的打包版本。大小必须至少为 $((n \times (n + 1)) / 2)$ $((n \times (n + 1)) /2)$ 。
- 如果 $uplo = MUBLAS\_FILL\_MODE\_UPPER$ ：提供 $A$ 的上三角部分。
- 如果 $uplo = MUBLAS\_FILL\_MODE\_LOWER$ ：提供 $A$ 的下三角部分。

操作

hpr 函数执行矩阵-向量操作：

A := A + \alpha , x , x^H

其中：

$\alpha$ 是一个实数标量。
$x$ 是一个向量。
$A$ 是一个 $n \times n$ Hermitian 矩阵，以打包形式提供。

函数 mublasChpr2

mublasStatus mublasChpr2(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * x,
    mublas_int incx,
    const muComplex * y,
    mublas_int incy,
    muComplex * AP
)

函数 mublasZhpr2

mublasStatus mublasZhpr2(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * x,
    mublas_int incx,
    const muDoubleComplex * y,
    mublas_int incy,
    muDoubleComplex * AP
)

BLAS Level 2 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
uplo: [mublasFillMode_t] 指定 $A$ $A$ 的上三角或下三角部分在 $AP$ $A P$ 中提供。
- MUBLAS_FILL_MODE_UPPER: $A$ 的上三角部分在 $AP$ 中提供。
- MUBLAS_FILL_MODE_LOWER: $A$ 的下三角部分在 $AP$ 中提供。
n: [mublas_int] 矩阵 $A$ 的行数和列数。必须至少为0。
alpha: 设备或主机指针，指向复数标量 $\alpha$ 。
x: 设备指针，存储向量 $x$ 。
incx: [mublas_int] 指定 $x$ 元素的增量。
y: 设备指针，存储向量 $y$ 。
incy: [mublas_int] 指定 $y$ 元素的增量。
AP: 设备指针，存储指定三角部分的Hermitian矩阵 $A$ $A$ 的打包版本。大小必须至少为 $((n \times (n + 1)) / 2)$ $((n \times (n + 1)) /2)$ 。
- 如果 $uplo = MUBLAS\_FILL\_MODE\_UPPER$ ：提供 $A$ 的上三角部分。
- 如果 $uplo = MUBLAS\_FILL\_MODE\_LOWER$ ：提供 $A$ 的下三角部分。

操作

hpr2 函数执行矩阵-向量操作：

A := A + \alpha , x , y^H + \overline{\alpha} , y , x^H

其中：

$\alpha$ 是一个复数标量。
$x$ 和 $y$ 是向量。
$A$ 是一个 $n \times n$ Hermitian 矩阵，以打包形式提供。

函数 mublasSnrm2

mublasStatus mublasSnrm2(
    mublasHandle_t handle,
    mublas_int n,
    const float * x,
    mublas_int incx,
    float * result
)

函数 mublasScnrm2

mublasStatus mublasScnrm2(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * x,
    mublas_int incx,
    float * result
)

函数 mublasDznrm2

mublasStatus mublasDznrm2(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * x,
    mublas_int incx,
    double * result
)

函数 mublasDnrm2

mublasStatus mublasDnrm2(
    mublasHandle_t handle,
    mublas_int n,
    const double * x,
    mublas_int incx,
    double * result
)

BLAS Level 1 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
n: [mublas_int] 向量 $x$ 中的元素数量。
x: 设备指针，存储向量 $x$ 。
incx: [mublas_int] 指定 $x$ 元素的增量。
result: 设备或主机指针，存储 $nrm2$ 结果。如果 $n \leq 0$ 或 $incx \leq 0$ ，则返回值为 $0.0$ 。

操作

nrm2 函数计算实数或复数向量的欧几里得范数：

对于实数向量：

\text{result} := \sqrt{x^T x}

对于复数向量：

\text{result} := \sqrt{x^H x}

函数 mublasSrot

mublasStatus mublasSrot(
    mublasHandle_t handle,
    mublas_int n,
    float * x,
    mublas_int incx,
    float * y,
    mublas_int incy,
    const float * c,
    const float * s
)

函数 mublasCsrot

mublasStatus mublasCsrot(
    mublasHandle_t handle,
    mublas_int n,
    muComplex * x,
    mublas_int incx,
    muComplex * y,
    mublas_int incy,
    const float * c,
    const float * s
)

函数 mublasDrot

mublasStatus mublasDrot(
    mublasHandle_t handle,
    mublas_int n,
    double * x,
    mublas_int incx,
    double * y,
    mublas_int incy,
    const double * c,
    const double * s
)

函数 mublasZdrot

mublasStatus mublasZdrot(
    mublasHandle_t handle,
    mublas_int n,
    muDoubleComplex * x,
    mublas_int incx,
    muDoubleComplex * y,
    mublas_int incy,
    const double * c,
    const double * s
)

BLAS Level 1 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
n: [mublas_int] 向量 $x$ 和 $y$ 中的元素数量。
x: 设备指针，存储向量 $x$ 。
incx: [mublas_int] 指定 $x$ 元素的增量。
y: 设备指针，存储向量 $y$ 。
incy: [mublas_int] 指定 $y$ 元素的增量。
c: 设备或主机指针，存储旋转矩阵的标量余弦分量 ( $c = \cos(\alpha)$ )。
s: 设备或主机指针，存储旋转矩阵的标量正弦分量 ( $s = \sin(\alpha)$ )。

操作

rot 函数将Givens旋转矩阵应用于向量 $x$ 和 $y$ 。旋转由余弦和正弦分量 $c$ 和 $s$ 定义，分别与角度 $\alpha$ 相关：

\begin{bmatrix} x \ y \end{bmatrix} \leftarrow \begin{bmatrix} c & s \ -s & c \end{bmatrix} \begin{bmatrix} x \ y \end{bmatrix}

其中：

$c = \cos(\alpha)$
$s = \sin(\alpha)$

函数 mublasSrotg

mublasStatus mublasSrotg(
    mublasHandle_t handle,
    float * a,
    float * b,
    float * c,
    float * s
)

函数 mublasCrotg

mublasStatus mublasCrotg(
    mublasHandle_t handle,
    muComplex * a,
    muComplex * b,
    float * c,
    muComplex * s
)

函数 mublasDrotg

mublasStatus mublasDrotg(
    mublasHandle_t handle,
    double * a,
    double * b,
    double * c,
    double * s
)

函数 mublasZrotg

mublasStatus mublasZrotg(
    mublasHandle_t handle,
    muDoubleComplex * a,
    muDoubleComplex * b,
    double * c,
    muDoubleComplex * s
)

BLAS Level 1 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
a: 设备指针或主机指针，指向输入向量元素，用 $r$ 覆盖。
b: 设备指针或主机指针，指向输入向量元素，用 $z$ 覆盖。
c: 设备指针或主机指针，指向Givens旋转的余弦元素。
s: 设备指针或主机指针，指向Givens旋转的正弦元素。

操作

rotg 函数为向量 $(a, b)$ 创建Givens旋转矩阵。旋转矩阵由余弦和正弦分量 $c$ 和 $s$ 定义，并应用于向量：

\begin{bmatrix} a \ b \end{bmatrix} \leftarrow \begin{bmatrix} r \ z \end{bmatrix}

其中：

$r$ 是 $a$ 旋转后的新值。
$z$ 是 $b$ 旋转后的新值。
$c = \cos(\alpha)$
$s = \sin(\alpha)$

旋转的结果存储在 $a$ 和 $b$ 中，分别为 $r$ 和 $z$ 。

如果指针模式设置为 MUBLAS_POINTER_MODE_HOST，则该函数阻塞CPU直到GPU完成并将结果可用在主机内存中。如果设置为 MUBLAS_POINTER_MODE_DEVICE，则该函数立即返回，需要同步才能读取结果。

函数 mublasSrotm

mublasStatus mublasSrotm(
    mublasHandle_t handle,
    mublas_int n,
    float * x,
    mublas_int incx,
    float * y,
    mublas_int incy,
    const float * param
)

函数 mublasDrotm

mublasStatus mublasDrotm(
    mublasHandle_t handle,
    mublas_int n,
    double * x,
    mublas_int incx,
    double * y,
    mublas_int incy,
    const double * param
)

BLAS Level 1 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
n: [mublas_int] 向量 $x$ 和 $y$ 中的元素数量。
x: 设备指针，存储向量 $x$ 。
incx: [mublas_int] 指定 $x$ 元素的增量。
y: 设备指针，存储向量 $y$ 。
incy: [mublas_int] 指定 $y$ 元素的增量。
param: 设备或主机向量，定义旋转的5个元素：
- param[0]: 标志（定义矩阵 $H$ 的形式）。
- param[1]: $H_{11}$ （第一行，第一列的元素）。
- param[2]: $H_{21}$ （第二行，第一列的元素）。
- param[3]: $H_{12}$ （第一行，第二列的元素）。
- param[4]: $H_{22}$ （第二行，第二列的元素）。

标志定义矩阵 $H$ 的形式：

flag = -1: $H = \begin{pmatrix} H_{11} & H_{12} \ H_{21} & H_{22} \end{pmatrix}$
flag = 0: $H = \begin{pmatrix} 1.0 & H_{12} \ H_{21} & 1.0 \end{pmatrix}$
flag = 1: $H = \begin{pmatrix} H_{11} & 1.0 \ -1.0 & H_{22} \end{pmatrix}$
flag = -2: $H = \begin{pmatrix} 1.0 & 0.0 \ 0.0 & 1.0 \end{pmatrix}$

param 向量可以存储在主机或设备内存中，位置由调用 mublasSetPointerMode 指定。

操作

rotm 函数将由 param 定义的修改后的Givens旋转矩阵应用于向量 $x$ 和 $y$ 。执行的操作是：

\begin{pmatrix} x \ y \end{pmatrix} \leftarrow H \begin{pmatrix} x \ y \end{pmatrix}

其中 $H$ 是由 param 向量定义的四种可能矩阵之一。

函数 mublasSrotmg

mublasStatus mublasSrotmg(
    mublasHandle_t handle,
    float * d1,
    float * d2,
    float * x1,
    const float * y1,
    float * param
)

函数 mublasDrotmg

mublasStatus mublasDrotmg(
    mublasHandle_t handle,
    double * d1,
    double * d2,
    double * x1,
    const double * y1,
    double * param
)

BLAS Level 1 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
d1 设备指针或主机指针，指向输入标量，将被覆盖。
d2 设备指针或主机指针，指向输入标量，将被覆盖。
x1 设备指针或主机指针，指向输入标量，将被覆盖。
y1 设备指针或主机指针，指向输入标量。
param 设备向量或主机向量，定义旋转的5个元素。param[0] = 标志 param[1] = H11 param[2] = H21 param[3] = H12 param[4] = H22 标志参数定义矩阵 H 的形式：标志 = -1 => H = ( H11 H12 H21 H22 ) 标志 = 0 => H = ( 1.0 H12 H21 1.0 ) 标志 = 1 => H = ( H11 1.0 -1.0 H22 ) 标志 = -2 => H = ( 1.0 0.0 0.0 1.0 ) param 可以存储在主机或设备内存中，位置由调用 mublasSetPointerMode 指定。

rotmg 为向量 (d1 * x1, d2 * y1) 创建修改后的Givens旋转矩阵。参数可以存储在主机或设备内存中，位置由调用 mublasSetPointerMode 指定。如果指针模式设置为 MUBLAS_POINTER_MODE_HOST，则该函数阻塞CPU直到GPU完成并将结果可用在主机内存中。如果指针模式设置为 MUBLAS_POINTER_MODE_DEVICE，则该函数立即返回，需要同步才能读取结果。

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
d1: 设备指针或主机指针，指向输入标量，将被覆盖。
d2: 设备指针或主机指针，指向输入标量，将被覆盖。
x1: 设备指针或主机指针，指向输入标量，将被覆盖。
y1: 设备指针或主机指针，指向输入标量。
param: 设备或主机向量，定义旋转的5个元素：
- param[0]: 标志（定义矩阵 $H$ 的形式）。
- param[1]: $H_{11}$ （第一行，第一列的元素）。
- param[2]: $H_{21}$ （第二行，第一列的元素）。
- param[3]: $H_{12}$ （第一行，第二列的元素）。
- param[4]: $H_{22}$ （第二行，第二列的元素）。

标志定义矩阵 $H$ 的形式：

flag = -1: $H = \begin{pmatrix} H_{11} & H_{12} \ H_{21} & H_{22} \end{pmatrix}$
flag = 0: $H = \begin{pmatrix} 1.0 & H_{12} \ H_{21} & 1.0 \end{pmatrix}$
flag = 1: $H = \begin{pmatrix} H_{11} & 1.0 \ -1.0 & H_{22} \end{pmatrix}$
flag = -2: $H = \begin{pmatrix} 1.0 & 0.0 \ 0.0 & 1.0 \end{pmatrix}$

param 向量可以存储在主机或设备内存中，位置由调用 mublasSetPointerMode 指定。

操作

rotmg 函数为向量 $(d1 \cdot x1, d2 \cdot y1)$ 创建修改后的Givens旋转矩阵。参数可以存储在主机或设备内存中，位置由调用 mublasSetPointerMode 指定。

如果指针模式设置为 MUBLAS_POINTER_MODE_HOST，则该函数阻塞CPU直到GPU完成并将结果可用在主机内存中。

如果指针模式设置为 MUBLAS_POINTER_MODE_DEVICE，则该函数立即返回，需要同步才能读取结果。

函数 mublasSsbmv

mublasStatus mublasSsbmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    mublas_int k,
    const float * alpha,
    const float * A,
    mublas_int lda,
    const float * x,
    mublas_int incx,
    const float * beta,
    float * y,
    mublas_int incy
)

函数 mublasDsbmv

mublasStatus mublasDsbmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    mublas_int k,
    const double * alpha,
    const double * A,
    mublas_int lda,
    const double * x,
    mublas_int incx,
    const double * beta,
    double * y,
    mublas_int incy
)

BLAS Level 2 API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
uplo: [mublasFillMode_t] 指定使用 $A$ 的上部（MUBLAS_FILL_MODE_UPPER）或下部（MUBLAS_FILL_MODE_LOWER）。如果 MUBLAS_FILL_MODE_UPPER，则不引用 $A$ 的下部。如果 MUBLAS_FILL_MODE_LOWER，则不引用 $A$ 的上部。
n: [mublas_int] 对称带状矩阵 $A$ 的阶数（行数和列数）。
k: [mublas_int] 对称带状矩阵 $A$ 中的次对角线和超对角线数量。
alpha: [float] 指定标量 $\alpha$ 。
A: 指向存储在GPU上的对称带状矩阵 $A$ 的指针。
lda: [mublas_int] 指定包含 $A$ 的数组的领先维度。必须至少为 $k + 1$ 。
x: 指向存储在GPU上的向量 $x$ 的指针。
incx: [mublas_int] 指定 $x$ 元素的增量。
beta: [float] 指定标量 $\beta$ 。
y: 指向存储在GPU上的向量 $y$ 的指针。
incy: [mublas_int] 指定 $y$ 元素的增量。

操作

sbmv 函数执行矩阵-向量操作：

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

其中：

$\alpha$ 和 $\beta$ 是标量，
$x$ 和 $y$ 是 $n$ 元素向量，
$A$ 是一个阶数为 $n$ 的对称带状矩阵，有 $k$ 个次对角线和超对角线，以紧凑形式存储，如 lda 参数指定。

函数 mublasCscal

mublasStatus mublasCscal(
    mublasHandle_t handle,
    mublas_int n,
    const muComplex * alpha,
    muComplex * x,
    mublas_int incx
)

函数 mublasZscal

mublasStatus mublasZscal(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * alpha,
    muDoubleComplex * x,
    mublas_int incx
)

函数 mublasCsscal

mublasStatus mublasCsscal(
    mublasHandle_t handle,
    mublas_int n,
    const float * alpha,
    muComplex * x,
    mublas_int incx
)

函数 mublasSscal

mublasStatus mublasSscal(
    mublasHandle_t handle,
    mublas_int n,
    const float * alpha,
    float * x,
    mublas_int incx
)

函数 mublasDscal

mublasStatus mublasDscal(
    mublasHandle_t handle,
    mublas_int n,
    const double * alpha,
    double * x,
    mublas_int incx
)

函数 mublasZscal

mublasStatus mublasZscal(
    mublasHandle_t handle,
    mublas_int n,
    const muDoubleComplex * alpha,
    muDoubleComplex * x,
    mublas_int incx
)

BLAS Level 1 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] x 中的元素数量。
alpha 设备指针或主机指针，指向标量 alpha。
x 设备指针，存储向量 x。
incx [mublas_int] 指定 x 元素的增量。

操作

scal 将向量 $x$ 的每个元素乘以标量 $\alpha$ ：

x := \alpha \cdot x

函数 mublasSspmv

mublasStatus mublasSspmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const float * alpha,
    const float * A,
    const float * x,
    mublas_int incx,
    const float * beta,
    float * y,
    mublas_int incy
)

函数 mublasDspmv

mublasStatus mublasDspmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const double * alpha,
    const double * A,
    const double * x,
    mublas_int incx,
    const double * beta,
    double * y,
    mublas_int incy
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo mublasFillMode_t 指定是否引用 'MUBLAS_FILL_MODE_UPPER' 上部或 'MUBLAS_FILL_MODE_LOWER' 下部。如果 MUBLAS_FILL_MODE_UPPER，则不引用 $A$ 的下部。如果 MUBLAS_FILL_MODE_LOWER，则不引用 $A$ 的上部。
n [mublas_int] 向量 $x$ 和 $y$ 中的元素数量。
alpha 指定标量 $\alpha$ 。
A 指向存储在GPU上的矩阵 $A$ 的指针。
x 指向存储在GPU上的向量 $x$ 的指针。
incx [mublas_int] 指定 $x$ 元素的增量。
beta 指定标量 $\beta$ 。
y 指向存储在GPU上的向量 $y$ 的指针。
incy [mublas_int] 指定 $y$ 元素的增量。

操作

spmv 函数执行矩阵-向量操作：

y := \alpha A x + \beta y

其中 $\alpha$ 和 $\beta$ 是标量， $x$ 和 $y$ 是 $n$ 元素向量， $A$ 是一个打包的对称矩阵，大小为 $n \times n$ ，可以是上三角或下三角。

函数 mublasSspr

mublasStatus mublasSspr(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const float * alpha,
    const float * x,
    mublas_int incx,
    float * AP
)

函数 mublasDspr

mublasStatus mublasDspr(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const double * alpha,
    const double * x,
    mublas_int incx,
    double * AP
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定是否引用 'MUBLAS_FILL_MODE_UPPER' 上部或 'MUBLAS_FILL_MODE_LOWER' 下部：
- MUBLAS_FILL_MODE_UPPER: $A$ 的上三角部分在 $AP$ 中提供。
- MUBLAS_FILL_MODE_LOWER: $A$ 的下三角部分在 $AP$ 中提供。
n [mublas_int] 矩阵 $A$ 的行数和列数，必须至少为0。
alpha 设备指针或主机指针，指向标量 $\alpha$ 。
x 设备指针，存储向量 $x$ 。
incx [mublas_int] 指定 $x$ 元素的增量。
AP 设备指针，存储指定三角部分的对称矩阵 $A$ $A$ 的打包版本，至少大小为 $\frac{n(n+1)}{2}$ $\frac{n ( n + 1 )}{2}$ 。
- 如果 uplo == MUBLAS_FILL_MODE_UPPER，则提供对称矩阵 $A$ 的上三角部分。矩阵紧凑排列，使得 $AP$ 按列包含三角部分。
- 如果 uplo == MUBLAS_FILL_MODE_LOWER，则提供对称矩阵 $A$ 的下三角部分。矩阵紧凑排列，使得 $AP$ 按列包含三角部分。

操作

spr 函数执行矩阵-向量操作：

A := A + \alpha x x^T

其中 $\alpha$ 是标量， $x$ 是向量， $A$ 是一个 $n \times n$ 对称矩阵，以打包形式提供。

函数 mublasSspr2

mublasStatus mublasSspr2(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const float * alpha,
    const float * x,
    mublas_int incx,
    const float * y,
    mublas_int incy,
    float * AP
)

函数 mublasDspr2

mublasStatus mublasDspr2(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const double * alpha,
    const double * x,
    mublas_int incx,
    const double * y,
    mublas_int incy,
    double * AP
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定是否引用 'MUBLAS_FILL_MODE_UPPER' 上部或 'MUBLAS_FILL_MODE_LOWER' 下部：
- MUBLAS_FILL_MODE_UPPER: $A$ 的上三角部分在 $AP$ 中提供。
- MUBLAS_FILL_MODE_LOWER: $A$ 的下三角部分在 $AP$ 中提供。
n [mublas_int] 矩阵 $A$ 的行数和列数，必须至少为0。
alpha 设备指针或主机指针，指向标量 $\alpha$ 。
x 设备指针，存储向量 $x$ 。
incx [mublas_int] 指定 $x$ 元素的增量。
y 设备指针，存储向量 $y$ 。
incy [mublas_int] 指定 $y$ 元素的增量。
AP 设备指针，存储指定三角部分的对称矩阵 $A$ $A$ 的打包版本，至少大小为 $\frac{n(n+1)}{2}$ $\frac{n ( n + 1 )}{2}$ 。
- 如果 uplo == MUBLAS_FILL_MODE_UPPER，则提供对称矩阵 $A$ 的上三角部分。矩阵紧凑排列，使得 $AP$ 按列包含三角部分。
- 如果 uplo == MUBLAS_FILL_MODE_LOWER，则提供对称矩阵 $A$ 的下三角部分。矩阵紧凑排列，使得 $AP$ 按列包含三角部分。

操作

spr2 函数执行矩阵-向量操作：

A := A + \alpha x y^T + \alpha y x^T

其中 $\alpha$ 是标量， $x$ 和 $y$ 是向量， $A$ 是一个 $n \times n$ 对称矩阵，以打包形式提供。

函数 mublasCswap

mublasStatus mublasCswap(
    mublasHandle_t handle,
    mublas_int n,
    muComplex * x,
    mublas_int incx,
    muComplex * y,
    mublas_int incy
)

BLAS Level 1 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] $x$ 和 $y$ 中的元素数量。
x 设备指针，存储向量 $x$ 。
incx [mublas_int] 指定 $x$ 元素的增量。
y 设备指针，存储向量 $y$ 。
incy [mublas_int] 指定 $y$ 元素的增量。

操作

swap 函数交换向量 $x$ 和 $y$ ：

y := x; \quad x := y

函数 mublasSswap

mublasStatus mublasSswap(
    mublasHandle_t handle,
    mublas_int n,
    float * x,
    mublas_int incx,
    float * y,
    mublas_int incy
)

函数 mublasDswap

mublasStatus mublasDswap(
    mublasHandle_t handle,
    mublas_int n,
    double * x,
    mublas_int incx,
    double * y,
    mublas_int incy
)

函数 mublasZswap

mublasStatus mublasZswap(
    mublasHandle_t handle,
    mublas_int n,
    muDoubleComplex * x,
    mublas_int incx,
    muDoubleComplex * y,
    mublas_int incy
)

BLAS Level 1 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
n [mublas_int] $x$ 和 $y$ 中的元素数量。
x 设备指针，存储向量 $x$ 。
incx [mublas_int] 指定 $x$ 元素的增量。
y 设备指针，存储向量 $y$ 。
incy [mublas_int] 指定 $y$ 元素的增量。

操作

swap 函数交换向量 $x$ 和 $y$ ：

y := x; \quad x := y

函数 mublasSsymm

mublasStatus mublasSsymm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublas_int m,
    mublas_int n,
    const float * alpha,
    const float * A,
    mublas_int lda,
    const float * B,
    mublas_int ldb,
    const float * beta,
    float * C,
    mublas_int ldc
)

函数 mublasCsymm

mublasStatus mublasCsymm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublas_int m,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    const muComplex * B,
    mublas_int ldb,
    const muComplex * beta,
    muComplex * C,
    mublas_int ldc
)

函数 mublasDsymm

mublasStatus mublasDsymm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublas_int m,
    mublas_int n,
    const double * alpha,
    const double * A,
    mublas_int lda,
    const double * B,
    mublas_int ldb,
    const double * beta,
    double * C,
    mublas_int ldc
)

函数 mublasZsymm

mublasStatus mublasZsymm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublas_int m,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * A,
    mublas_int lda,
    const muDoubleComplex * B,
    mublas_int ldb,
    const muDoubleComplex * beta,
    muDoubleComplex * C,
    mublas_int ldc
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
side [mublasSideMode_t]
- MUBLAS_SIDE_LEFT: $C := \alpha A B + \beta C$
- MUBLAS_SIDE_RIGHT: $C := \alpha B A + \beta C$
uplo [mublasFillMode_t]
- MUBLAS_FILL_MODE_UPPER: $A$ 是一个上三角矩阵
- MUBLAS_FILL_MODE_LOWER: $A$ 是一个下三角矩阵
m [mublas_int] $B$ 和 $C$ 的行数， $m \geq 0$ 。
n [mublas_int] $B$ 和 $C$ 的列数， $n \geq 0$ 。
alpha 标量 $\alpha$ 。当 $\alpha$ 为零时，不引用 $A$ 和 $B$ 。
A 指向存储在GPU上的矩阵 $A$ 的指针。如果 side == MUBLAS_SIDE_LEFT，则 $A$ 是 $m \times m$ ，如果 side == MUBLAS_SIDE_RIGHT，则 $A$ 是 $n \times n$ ；仅访问上/下三角部分。
lda [mublas_int] 指定 $A$ 的第一维度。如果 side == MUBLAS_SIDE_LEFT，则 $\text{lda} \geq \max(1, m)$ ，否则 $\text{lda} \geq \max(1, n)$ 。
B 指向存储在GPU上的矩阵 $B$ 的指针。矩阵尺寸为 $m \times n$ 。
ldb [mublas_int] 指定 $B$ 的第一维度。 $\text{ldb} \geq \max(1, m)$ 。
beta 标量 $\beta$ 。当 $\beta$ 为零时，不需要在进入前设置 $C$ 。
C 指向存储在GPU上的矩阵 $C$ 的指针。矩阵尺寸为 $m \times n$ 。
ldc [mublas_int] 指定 $C$ 的第一维度。 $\text{ldc} \geq \max(1, m)$ 。

操作

symm 函数执行矩阵-矩阵操作：

如果 side == MUBLAS_SIDE_LEFT，则 $C := \alpha A B + \beta C$
如果 side == MUBLAS_SIDE_RIGHT，则 $C := \alpha B A + \beta C$

其中 $\alpha$ 和 $\beta$ 是标量， $B$ 和 $C$ 是 $m \times n$ 矩阵， $A$ 是一个对称矩阵，存储为上三角或下三角。

函数 mublasSsymmStridedBatched

mublasStatus mublasSsymmStridedBatched(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublas_int m,
    mublas_int n,
    const float * alpha,
    const float * A,
    mublas_int lda,
    mublas_stride stride_A,
    const float * B,
    mublas_int ldb,
    mublas_stride stride_B,
    const float * beta,
    float * C,
    mublas_int ldc,
    mublas_stride stride_C,
    mublas_int batch_count
)

函数 mublasCsymmStridedBatched

mublasStatus mublasCsymmStridedBatched(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublas_int m,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    mublas_stride stride_A,
    const muComplex * B,
    mublas_int ldb,
    mublas_stride stride_B,
    const muComplex * beta,
    muComplex * C,
    mublas_int ldc,
    mublas_stride stride_C,
    mublas_int batch_count
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
side [mublasSideMode_t]
- MUBLAS_SIDE_LEFT: $C_i := \alpha A_i B\_i + \beta C\_i$
- MUBLAS_SIDE_RIGHT: $C_i := \alpha B\_i A\_i + \beta C\_i$
uplo [mublasFillMode_t]
- MUBLAS_FILL_MODE_UPPER: $A_i$ 是一个上三角矩阵
- MUBLAS_FILL_MODE_LOWER: $A_i$ 是一个下三角矩阵
m [mublas_int] 指定 $B_i$ 和 $C_i$ 的行数， $m \geq 0$ 。
n [mublas_int] 指定 $B_i$ 和 $C_i$ 的列数， $n \geq 0$ 。
alpha 标量 $\alpha$ 。当 $\alpha$ 为零时，不引用 $A_i$ 和 $B_i$ 。
A 设备指针，指向第一个矩阵 $A\_1$ 。如果 side == MUBLAS_SIDE_LEFT，则 $A_i$ 是 $m \times m$ ，如果 side == MUBLAS_SIDE_RIGHT，则 $A_i$ 是 $n \times n$ ；仅访问上/下三角部分。
lda [mublas_int] 指定 $A_i$ 的第一维度。如果 side == MUBLAS_SIDE_LEFT，则 $\text{lda} \geq \max(1, m)$ ，否则 $\text{lda} \geq \max(1, n)$ 。
stride_A [mublas_stride] 从一个矩阵 ( $A_i$ ) 的开始到下一个矩阵 ( $A\_{i+1}$ ) 的步长。
B 设备指针，指向第一个矩阵 $B\_1$ ，尺寸为 $(\text{ldb}, n)$ ，在GPU上。
ldb [mublas_int] 指定 $B_i$ 的第一维度。 $\text{ldb} \geq \max(1, m)$ 。
stride_B [mublas_stride] 从一个矩阵 ( $B_i$ ) 的开始到下一个矩阵 ( $B\_{i+1}$ ) 的步长。
beta 标量 $\beta$ 。当 $\beta$ 为零时，不需要在进入前设置 $C$ 。
C 设备指针，指向第一个矩阵 $C_1$ ，尺寸为 $(\text{ldc}, n)$ ，在GPU上。
ldc [mublas_int] 指定 $C$ 的第一维度。 $\text{ldc} \geq \max(1, m)$ 。
stride_C [mublas_stride] 从一个矩阵 ( $C_i$ ) 的开始到下一个矩阵 ( $C_{i+1}$ ) 的步长。
batch_count [mublas_int] 批次中的实例数量。

操作

symm_strided_batched 函数执行一批矩阵-矩阵操作：

如果 side == MUBLAS_SIDE_LEFT，则 $C_i := \alpha A_i B_i + \beta C_i$
如果 side == MUBLAS_SIDE_RIGHT，则 $C_i := \alpha B_i A_i + \beta C_i$

其中 $\alpha$ 和 $\beta$ 是标量， $B_i$ 和 $C_i$ 是 $m \times n$ 矩阵， $A_i$ 是一个对称矩阵，存储为上三角或下三角。

函数 mublasSsymv

mublasStatus mublasSsymv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const float * alpha,
    const float * A,
    mublas_int lda,
    const float * x,
    mublas_int incx,
    const float * beta,
    float * y,
    mublas_int incy
)

函数 mublasDsymv

mublasStatus mublasDsymv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const double * alpha,
    const double * A,
    mublas_int lda,
    const double * x,
    mublas_int incx,
    const double * beta,
    double * y,
    mublas_int incy
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定是否引用 $A$ $A$ 的上部或下部：
- MUBLAS_FILL_MODE_UPPER: 不引用 $A$ 的下部
- MUBLAS_FILL_MODE_LOWER: 不引用 $A$ 的上部
n [mublas_int] 向量 $x$ 和 $y$ 中的元素数量。
alpha 标量 $\alpha$ 。
A 指向存储在GPU上的矩阵 $A$ 的指针。 $A$ 是一个 $n \times n$ 对称矩阵，存储为上三角或下三角。
lda [mublas_int] 指定 $A$ 的领先维度。
x 指向存储在GPU上的向量 $x$ 的指针。
incx [mublas_int] 指定 $x$ 元素的增量。
beta 标量 $\beta$ 。
y 指向存储在GPU上的向量 $y$ 的指针。
incy [mublas_int] 指定 $y$ 元素的增量。

操作

symv 函数执行矩阵-向量操作：

y := \alpha A x + \beta y

其中 $\alpha$ 和 $\beta$ 是标量， $x$ 和 $y$ 是 $n$ 元素向量， $A$ 是一个对称的 $n \times n$ 矩阵，存储为上三角或下三角。

函数 mublasSsyr

mublasStatus mublasSsyr(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const float * alpha,
    const float * x,
    mublas_int incx,
    float * A,
    mublas_int lda
)

函数 mublasDsyr

mublasStatus mublasDsyr(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const double * alpha,
    const double * x,
    mublas_int incx,
    double * A,
    mublas_int lda
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定是否引用矩阵 $A$ $A$ 的上部或下部：
- MUBLAS_FILL_MODE_UPPER：不引用 $A$ 的下部
- MUBLAS_FILL_MODE_LOWER：不引用 $A$ 的上部
n [mublas_int] 矩阵 $A$ 的行数和列数。
alpha 设备指针或主机指针，指向标量 $\alpha$ 。
x 存储向量 $x$ 的设备指针。
incx [mublas_int] 指定 $x$ 元素的增量。
A 存储矩阵 $A$ 的设备指针。
lda [mublas_int] 指定 $A$ 的领先维度。

操作

syr函数执行矩阵-向量操作：

$A := A + \alpha x x^T$

其中 $\alpha$ 是标量， $x$ 是向量， $A$ 是 $n \times n$ 对称矩阵。

函数 mublasSsyr2

mublasStatus mublasSsyr2(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const float * alpha,
    const float * x,
    mublas_int incx,
    const float * y,
    mublas_int incy,
    float * A,
    mublas_int lda
)

函数 mublasDsyr2

mublasStatus mublasDsyr2(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublas_int n,
    const double * alpha,
    const double * x,
    mublas_int incx,
    const double * y,
    mublas_int incy,
    double * A,
    mublas_int lda
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定是否引用矩阵 $A$ $A$ 的上部或下部：
- MUBLAS_FILL_MODE_UPPER：不引用 $A$ 的下部
- MUBLAS_FILL_MODE_LOWER：不引用 $A$ 的上部
n [mublas_int] 矩阵 $A$ 的行数和列数。
alpha 设备指针或主机指针，指向标量 $\alpha$ 。
x 存储向量 $x$ 的设备指针。
incx [mublas_int] 指定 $x$ 元素的增量。
y 存储向量 $y$ 的设备指针。
incy [mublas_int] 指定 $y$ 元素的增量。
A 存储矩阵 $A$ 的设备指针。
lda [mublas_int] 指定 $A$ 的领先维度。

操作

syr2函数执行矩阵-向量操作：

$A := A + \alpha x y^T + \alpha y x^T$

其中 $\alpha$ 是标量， $x$ 和 $y$ 是向量， $A$ 是 $n \times n$ 对称矩阵。

函数 mublasCsyr2k

mublasStatus mublasCsyr2k(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublas_int n,
    mublas_int k,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    const muComplex * B,
    mublas_int ldb,
    const muComplex * beta,
    muComplex * C,
    mublas_int ldc
)

函数 mublasSsyr2k

mublasStatus mublasSsyr2k(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublas_int n,
    mublas_int k,
    const float * alpha,
    const float * A,
    mublas_int lda,
    const float * B,
    mublas_int ldb,
    const float * beta,
    float * C,
    mublas_int ldc
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $C$ $C$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $C$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $C$ 是下三角矩阵
trans [mublasOperation_t] 指定对矩阵 $A$ $A$ 和 $B$ $B$ 的操作：
- MUBLAS_OP_T： $op(A) = A^T$ ， $op(B) = B^T$
- MUBLAS_OP_N： $op(A) = A$ ， $op(B) = B$
n [mublas_int] 指定 $C$ 的行数和列数。 $n \geq 0$ 。
k [mublas_int] 指定 $op(A)$ 和 $op(B)$ 的列数。 $k \geq 0$ 。
alpha 指定标量 $\alpha$ 。当 $\alpha$ 为零时，不引用 $A$ 和 $B$ 。
A 指向GPU上的矩阵 $A$ 的指针。矩阵尺寸为 $(\text{lda}, k)$ 如果 $trans = MUBLAS\_OP\_N$ ，否则为 $(\text{lda}, n)$ 。只访问 $A$ 的上/下三角部分。
lda [mublas_int] 指定 $A$ 的第一维度。如果 $trans = MUBLAS\_OP\_N$ ， $\text{lda} \geq \max(1, n)$ ，否则 $\text{lda} \geq \max(1, k)$ 。
B 指向GPU上的矩阵 $B$ 的指针。矩阵尺寸为 $(\text{ldb}, k)$ 如果 $trans = MUBLAS\_OP\_N$ ，否则为 $(\text{ldb}, n)$ 。只访问 $B$ 的上/下三角部分。
ldb [mublas_int] 指定 $B$ 的第一维度。如果 $trans = MUBLAS\_OP\_N$ ， $\text{ldb} \geq \max(1, n)$ ，否则 $\text{ldb} \geq \max(1, k)$ 。
beta 指定标量 $\beta$ 。当 $\beta$ 为零时，不需要在进入前设置 $C$ 。
C 指向GPU上的矩阵 $C$ 的指针。
ldc [mublas_int] 指定 $C$ 的第一维度。 $\text{ldc} \geq \max(1, n)$ 。

操作

syr2k函数执行对称秩-2k更新：

$C := \alpha ( op(A) \cdot op(B)^T + op(B) \cdot op(A)^T ) + \beta C$

其中 $\alpha$ 和 $\beta$ 是标量， $op(A)$ 和 $op(B)$ 是 $n \times k$ 矩阵， $C$ 是作为上三角或下三角存储的 $n \times n$ 对称矩阵。

操作可以是：

$op(A) = A$ ， $op(B) = B$ 当 $trans = \text{MUBLAS\_OP\_N}$
$op(A) = A^T$ ， $op(B) = B^T$ 当 $trans = \text{MUBLAS\_OP\_T}$

函数 mublasCsyrk

mublasStatus mublasCsyrk(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    const muComplex * beta,
    muComplex * C,
    mublas_int ldc
)

函数 mublasSsyrk

mublasStatus mublasSsyrk(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const float * alpha,
    const float * A,
    mublas_int lda,
    const float * beta,
    float * C,
    mublas_int ldc
)

函数 mublasDsyrk

mublasStatus mublasDsyrk(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const double * alpha,
    const double * A,
    mublas_int lda,
    const double * beta,
    double * C,
    mublas_int ldc
)

函数 mublasZsyrk

mublasStatus mublasZsyrk(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const muDoubleComplex * alpha,
    const muDoubleComplex * A,
    mublas_int lda,
    const muDoubleComplex * beta,
    muDoubleComplex * C,
    mublas_int ldc
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $C$ $C$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $C$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $C$ 是下三角矩阵
transA [mublasOperation_t] 指定对矩阵 $A$ $A$ 的操作：
- MUBLAS_OP_T： $op(A) = A^T$
- MUBLAS_OP_N： $op(A) = A$
- MUBLAS_OP_C： $op(A) = A^T$
n [mublas_int] 指定 $C$ 的行数和列数。 $n \geq 0$ 。
k [mublas_int] 指定 $op(A)$ 的列数。 $k \geq 0$ 。
alpha 指定标量 $\alpha$ 。当 $\alpha$ 为零时，不引用 $A$ ，且不需要在进入前设置。
A 指向GPU上的矩阵 $A$ 的指针。矩阵尺寸为 $(\text{lda}, k)$ 如果 $transA = MUBLAS\_OP\_N$ ，否则为 $(\text{lda}, n)$ 。只访问 $A$ 的上/下三角部分。
lda [mublas_int] 指定 $A$ 的第一维度。如果 $transA = MUBLAS\_OP\_N$ ， $\text{lda} \geq \max(1, n)$ ，否则 $\text{lda} \geq \max(1, k)$ 。
beta 指定标量 $\beta$ 。当 $\beta$ 为零时，不需要在进入前设置 $C$ 。
C 指向GPU上的矩阵 $C$ 的指针。
ldc [mublas_int] 指定 $C$ 的第一维度。 $\text{ldc} \geq \max(1, n)$ 。

操作

syrk函数执行对称秩-k更新：

$C := \alpha \cdot op(A) \cdot op(A)^T + \beta \cdot C$

其中 $\alpha$ 和 $\beta$ 是标量， $op(A)$ 是 $n \times k$ 矩阵， $C$ 是作为上三角或下三角存储的对称 $n \times n$ 矩阵。

操作可以是：

$op(A) = A$ ，且 $A$ 是 $n \times k$ 如果 $transA = \text{MUBLAS\_OP\_N}$
$op(A) = A^T$ ，且 $A$ 是 $k \times n$ 如果 $transA = \text{MUBLAS\_OP\_T}$

注意：MUBLAS_OP_C不支持复数类型。见cherk和zherk。

函数 mublasCsyrkStridedBatched

mublasStatus mublasCsyrkStridedBatched(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    mublas_stride stride_A,
    const muComplex * beta,
    muComplex * C,
    mublas_int ldc,
    mublas_stride stride_C,
    mublas_int batch_count
)

函数 mublasSsyrkStridedBatched

mublasStatus mublasSsyrkStridedBatched(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublas_int n,
    mublas_int k,
    const float * alpha,
    const float * A,
    mublas_int lda,
    mublas_stride stride_A,
    const float * beta,
    float * C,
    mublas_int ldc,
    mublas_stride stride_C,
    mublas_int batch_count
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $C_i$ $C_{i}$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $C_i$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $C_i$ 是下三角矩阵
transA [mublasOperation_t] 指定对矩阵 $A_i$ $A_{i}$ 的操作：
- MUBLAS_OP_T： $op(A_i) = A_i^T$
- MUBLAS_OP_N： $op(A_i) = A_i$
- MUBLAS_OP_C： $op(A_i) = A_i^T$
n [mublas_int] 指定 $C_i$ 的行数和列数。 $n \geq 0$ 。
k [mublas_int] 指定 $op(A_i)$ 的列数。 $k \geq 0$ 。
alpha 指定标量 $\alpha$ 。当 $\alpha$ 为零时，不引用 $A_i$ ，且不需要在进入前设置。
A 指向GPU上的第一个矩阵 $A_1$ 的指针。矩阵尺寸为 $(\text{lda}, k)$ 如果 $transA = MUBLAS\_OP\_N$ ，否则为 $(\text{lda}, n)$ 。
lda [mublas_int] 指定 $A_i$ 的第一维度。如果 $transA = MUBLAS\_OP\_N$ ， $\text{lda} \geq \max(1, n)$ ，否则 $\text{lda} \geq \max(1, k)$ 。
stride_A [mublas_stride] 指定一个矩阵( $A_i$ )到下一个矩阵( $A_{i+1}$ )的跨度。
beta 指定标量 $\beta$ 。当 $\beta$ 为零时，不需要在进入前设置 $C_i$ 。
C 指向GPU上的第一个矩阵 $C_1$ 的指针。
ldc [mublas_int] 指定 $C$ 的第一维度。 $\text{ldc} \geq \max(1, n)$ 。
stride_C [mublas_stride] 指定一个矩阵( $C_i$ )到下一个矩阵( $C_{i+1}$ )的跨度。
batch_count [mublas_int] 批处理中的实例数量。

操作

syrk_strided_batched函数执行一批矩阵-矩阵操作，进行对称秩-k更新：

$C_i := \alpha \cdot op(A_i) \cdot op(A_i)^T + \beta \cdot C_i$

其中 $\alpha$ 和 $\beta$ 是标量， $op(A_i)$ 是 $n \times k$ 矩阵， $C_i$ 是作为上三角或下三角存储的对称 $n \times n$ 矩阵。

操作可以是：

$op(A_i) = A_i$ ，且 $A_i$ 是 $n \times k$ 如果 $transA = \text{MUBLAS\_OP\_N}$
$op(A_i) = A_i^T$ ，且 $A_i$ 是 $k \times n$ 如果 $transA = \text{MUBLAS\_OP\_T}$

注意：MUBLAS_OP_C不支持复数类型。见cherk和zherk。

函数 mublasCsyrkx

mublasStatus mublasCsyrkx(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublas_int n,
    mublas_int k,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    const muComplex * B,
    mublas_int ldb,
    const muComplex * beta,
    muComplex * C,
    mublas_int ldc
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $C$ $C$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $C$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $C$ 是下三角矩阵
trans [mublasOperation_t] 指定对矩阵 $A$ $A$ 和 $B$ $B$ 的操作：
- MUBLAS_OP_T： $op(A) = A^T$ ， $op(B) = B^T$
- MUBLAS_OP_N： $op(A) = A$ ， $op(B) = B$
n [mublas_int] 指定 $C$ 的行数和列数。 $n \geq 0$ 。
k [mublas_int] 指定 $op(A)$ 和 $op(B)$ 的列数。 $k \geq 0$ 。
alpha 指定标量 $\alpha$ 。当 $\alpha$ 为零时，不引用 $A$ ，且不需要在进入前设置。
A 指向GPU上的矩阵 $A$ 的指针。矩阵尺寸为 $(\text{lda}, k)$ 如果 $trans = MUBLAS\_OP\_N$ ，否则为 $(\text{lda}, n)$ 。
lda [mublas_int] 指定 $A$ 的第一维度。如果 $trans = MUBLAS\_OP\_N$ ， $\text{lda} \geq \max(1, n)$ ，否则 $\text{lda} \geq \max(1, k)$ 。
B 指向GPU上的矩阵 $B$ 的指针。矩阵尺寸为 $(\text{ldb}, k)$ 如果 $trans = MUBLAS\_OP\_N$ ，否则为 $(\text{ldb}, n)$ 。
ldb [mublas_int] 指定 $B$ 的第一维度。如果 $trans = MUBLAS\_OP\_N$ ， $\text{ldb} \geq \max(1, n)$ ，否则 $\text{ldb} \geq \max(1, k)$ 。
beta 指定标量 $\beta$ 。当 $\beta$ 为零时，不需要在进入前设置 $C$ 。
C 指向GPU上的矩阵 $C$ 的指针。
ldc [mublas_int] 指定 $C$ 的第一维度。 $\text{ldc} \geq \max(1, n)$ 。

操作

syrkx函数执行矩阵-矩阵操作，进行对称秩-k更新：

$C := \alpha \cdot op(A) \cdot op(B)^T + \beta \cdot C$

其中 $\alpha$ 和 $\beta$ 是标量， $op(A)$ 和 $op(B)$ 是 $n \times k$ 矩阵， $C$ 是作为上三角或下三角存储的对称 $n \times n$ 矩阵。

操作可以是：

$op(A) = A$ ， $op(B) = B$ ，且 $A$ 和 $B$ 是 $n \times k$ 如果 $trans = \text{MUBLAS\_OP\_N}$
$op(A) = A^T$ ， $op(B) = B^T$ ，且 $A$ 和 $B$ 是 $k \times n$ 如果 $trans = \text{MUBLAS\_OP\_T}$

此例程只应在 $op(A) \cdot op(B)^T$ 的结果保证为对称时使用。

函数 mublasCsyrkxStridedBatched

mublasStatus mublasCsyrkxStridedBatched(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublas_int n,
    mublas_int k,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    mublas_stride stride_A,
    const muComplex * B,
    mublas_int ldb,
    mublas_stride stride_B,
    const muComplex * beta,
    muComplex * C,
    mublas_int ldc,
    mublas_stride stride_C,
    mublas_int batch_count
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $C_i$ $C_{i}$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $C_i$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $C_i$ 是下三角矩阵
trans [mublasOperation_t] 指定对矩阵 $A_i$ $A_{i}$ 和 $B_i$ $B_{i}$ 的操作：
- MUBLAS_OP_T： $op(A_i) = A_i^T$ ， $op(B_i) = B_i^T$
- MUBLAS_OP_N： $op(A_i) = A_i$ ， $op(B_i) = B_i$
n [mublas_int] 指定 $C_i$ 的行数和列数。 $n \geq 0$ 。
k [mublas_int] 指定 $op(A_i)$ 的列数。 $k \geq 0$ 。
alpha 指定标量 $\alpha$ 。当 $\alpha$ 为零时，不引用 $A_i$ ，且不需要在进入前设置。
A 指向GPU上的矩阵 $A_1$ 的指针。矩阵尺寸为 $(\text{lda}, k)$ 如果 $trans = \text{MUBLAS\_OP\_N}$ ，否则为 $(\text{lda}, n)$ 。
lda [mublas_int] 指定 $A_i$ 的第一维度。如果 $trans = \text{MUBLAS\_OP\_N}$ ， $\text{lda} \geq \max(1, n)$ ，否则 $\text{lda} \geq \max(1, k)$ 。
stride_A [mublas_stride] 指定一个矩阵( $A_i$ )到下一个矩阵( $A_{i+1}$ )的跨度。
B 指向GPU上的矩阵 $B_1$ 的指针。矩阵尺寸为 $(\text{ldb}, k)$ 如果 $trans = \text{MUBLAS\_OP\_N}$ ，否则为 $(\text{ldb}, n)$ 。
ldb [mublas_int] 指定 $B_i$ 的第一维度。如果 $trans = \text{MUBLAS\_OP\_N}$ ， $\text{ldb} \geq \max(1, n)$ ，否则 $\text{ldb} \geq \max(1, k)$ 。
stride_B [mublas_stride] 指定一个矩阵( $B_i$ )到下一个矩阵( $B_{i+1}$ )的跨度。
beta 指定标量 $\beta$ 。当 $\beta$ 为零时，不需要在进入前设置 $C_i$ 。
C 指向GPU上的第一个矩阵 $C_1$ 的指针。
ldc [mublas_int] 指定 $C$ 的第一维度。 $\text{ldc} \geq \max(1, n)$ 。
stride_C [mublas_stride] 指定一个矩阵( $C_i$ )到下一个矩阵( $C_{i+1}$ )的跨度。
batch_count [mublas_int] 批处理中的实例数量。

操作

syrkx_strided_batched函数执行一批矩阵-矩阵操作，进行对称秩-k更新：

$C_i := \alpha \cdot op(A_i) \cdot op(B_i)^T + \beta \cdot C_i$

其中 $\alpha$ 和 $\beta$ 是标量， $op(A_i)$ 和 $op(B_i)$ 是 $n \times k$ 矩阵， $C_i$ 是作为上三角或下三角存储的对称 $n \times n$ 矩阵。

操作可以是：

$op(A_i) = A_i$ ， $op(B_i) = B_i$ ，且 $A_i$ ， $B_i$ 是 $n \times k$ 如果 $trans = \text{MUBLAS\_OP\_N}$
$op(A_i) = A_i^T$ ， $op(B_i) = B_i^T$ ，且 $A_i$ ， $B_i$ 是 $k \times n$ 如果 $trans = \text{MUBLAS\_OP\_T}$

此例程只应在 $op(A_i) \cdot op(B_i)^T$ 的结果保证为对称时使用。

函数 mublasStbmv

mublasStatus mublasStbmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int k,
    const float * A,
    mublas_int lda,
    float * x,
    mublas_int incx
)

函数 mublasCtbmv

mublasStatus mublasCtbmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int k,
    const muComplex * A,
    mublas_int lda,
    muComplex * x,
    mublas_int incx
)

函数 mublasDtbmv

mublasStatus mublasDtbmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int k,
    const double * A,
    mublas_int lda,
    double * x,
    mublas_int incx
)

函数 mublasZtbmv

mublasStatus mublasZtbmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t trans,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int k,
    const muDoubleComplex * A,
    mublas_int lda,
    muDoubleComplex * x,
    mublas_int incx
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是否作为上带或下带存储：
- MUBLAS_FILL_MODE_UPPER： $A$ 是上带三角矩阵
- MUBLAS_FILL_MODE_LOWER： $A$ 是下带三角矩阵
trans [mublasOperation_t] 指定对矩阵 $A$ $A$ 的操作：
- MUBLAS_OP_T： $op(A) = A^T$
- MUBLAS_OP_N： $op(A) = A$
diag [mublasDiagType_t] 指定 $A$ $A$ 的对角线类型：
- MUBLAS_DIAG_UNIT：假设 $A$ 的主对角线只包含1，且不引用
- MUBLAS_DIAG_NON_UNIT：不对 $A$ 的主对角线做假设
m [mublas_int] 指定由 $A$ 表示的矩阵的行数和列数。
k [mublas_int] 指定 $A$ $A$ 的对角线条数：
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$ ， $k$ 指定 $A$ 的超对角线条数。
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$ ， $k$ 指定 $A$ 的次对角线条数。
- $k$ 必须满足 $k > 0$ 且 $k < \text{lda}$
A 存储带状三角矩阵 $A$ $A$ 的设备指针。
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$ ， $A$ 表示带有主对角线和 $k$ 个超对角线的上带三角矩阵。
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$ ， $A$ 表示带有主对角线和 $k$ 个次对角线的下带三角矩阵。
lda [mublas_int] 指定 $A$ 的领先维度。必须满足 $\text{lda} > k$ 。
x 存储向量 $x$ 的设备指针。
incx [mublas_int] 指定 $x$ 元素的增量。

操作

tbmv函数执行以下矩阵-向量操作之一：

$x := A \cdot x \quad \text{or} \quad x := A^T \cdot x \quad \text{or} \quad x := A^H \cdot x$

其中 $x$ 是向量， $A$ 是带状 $m \times m$ 矩阵。

函数 mublasStbsv

mublasStatus mublasStbsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    mublas_int k,
    const float * A,
    mublas_int lda,
    float * x,
    mublas_int incx
)

函数 mublasCtbsv

mublasStatus mublasCtbsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    mublas_int k,
    const muComplex * A,
    mublas_int lda,
    muComplex * x,
    mublas_int incx
)

函数 mublasDtbsv

mublasStatus mublasDtbsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    mublas_int k,
    const double * A,
    mublas_int lda,
    double * x,
    mublas_int incx
)

函数 mublasZtbsv

mublasStatus mublasZtbsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    mublas_int k,
    const muDoubleComplex * A,
    mublas_int lda,
    muDoubleComplex * x,
    mublas_int incx
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $A$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $A$ 是下三角矩阵
transA [mublasOperation_t] 指定对矩阵 $A$ $A$ 的操作：
- MUBLAS_OP_N：解 $A \cdot x = b$
- MUBLAS_OP_T：解 $A^T \cdot x = b$
- MUBLAS_OP_C：解 $A^H \cdot x = b$
diag [mublasDiagType_t] 指定 $A$ $A$ 的对角线类型：
- MUBLAS_DIAG_UNIT：假设 $A$ 是单位三角（即， $A$ 的对角线元素在计算中不使用）
- MUBLAS_DIAG_NON_UNIT：不假设 $A$ 是单位三角
n [mublas_int] 指定 $b$ 的行数。 $n \geq 0$ 。
k [mublas_int] 指定 $A$ $A$ 的对角线条数：
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$ ， $k$ 指定 $A$ 的超对角线条数。
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$ ， $k$ 指定 $A$ 的次对角线条数。
- $k \geq 0$
A 存储带状格式矩阵 $A$ 的设备指针。
lda [mublas_int] 指定 $A$ 的领先维度。 $\text{lda} \geq (k + 1)$ 。
x 存储输入向量 $b$ 的设备指针。被输出向量 $x$ 覆盖。
incx [mublas_int] 指定 $x$ 元素的增量。

操作

tbsv函数解以下方程组：

$A \cdot x = b \quad \text{or} \quad A^T \cdot x = b \quad \text{or} \quad A^H \cdot x = b$

其中 $x$ 和 $b$ 是向量， $A$ 是带状三角矩阵。

函数 mublasCtpmv

mublasStatus mublasCtpmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const muComplex * A,
    muComplex * x,
    mublas_int incx
)

函数 mublasStpmv

mublasStatus mublasStpmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const float * A,
    float * x,
    mublas_int incx
)

函数 mublasDtpmv

mublasStatus mublasDtpmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const double * A,
    double * x,
    mublas_int incx
)

函数 mublasZtpmv

mublasStatus mublasZtpmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const muDoubleComplex * A,
    muDoubleComplex * x,
    mublas_int incx
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $A$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $A$ 是下三角矩阵
transA [mublasOperation_t] 指定对矩阵 $A$ $A$ 的操作：
- MUBLAS_OP_N：解 $A \cdot x$
- MUBLAS_OP_T：解 $A^T \cdot x$
diag [mublasDiagType_t] 指定 $A$ $A$ 的对角线类型：
- MUBLAS_DIAG_UNIT：假设 $A$ 是单位三角（即， $A$ 的对角线元素在计算中不使用）
- MUBLAS_DIAG_NON_UNIT：不假设 $A$ 是单位三角
m [mublas_int] 指定 $A$ 的行数。 $m \geq 0$ 。
A 存储矩阵 $A$ $A$ 的设备指针。矩阵以紧凑形式存储：
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$ ，数组 $A$ 包含按列顺序紧凑存储的上三角矩阵。
- 如果 $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$ ，数组 $A$ 包含按列顺序紧凑存储的下三角矩阵。
- 当 $diag = \text{MUBLAS\_DIAG\_UNIT}$ 时，不引用 $A$ 的对角线元素，但假设为1。
x 存储向量 $x$ 的设备指针。
incx [mublas_int] 指定 $x$ 元素的增量。 $\text{incx}$ 不能为零。

操作

tpmv函数执行以下矩阵-向量操作：

$x = A \cdot x \quad \text{or} \quad x = A^T \cdot x$

其中 $x$ 是 $n$ 元素向量， $A$ 是以紧凑形式提供的 $n \times n$ 单位或非单位上三角或下三角矩阵。

向量 $x$ 被覆盖。

函数 mublasCtpsv

mublasStatus mublasCtpsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    const muComplex * AP,
    muComplex * x,
    mublas_int incx
)

函数 mublasStpsv

mublasStatus mublasStpsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    const float * AP,
    float * x,
    mublas_int incx
)

函数 mublasDtpsv

mublasStatus mublasDtpsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    const double * AP,
    double * x,
    mublas_int incx
)

函数 mublasZtpsv

mublasStatus mublasZtpsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int n,
    const muDoubleComplex * AP,
    muDoubleComplex * x,
    mublas_int incx
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是否作为上三角或下三角存储：
- MUBLAS_FILL_MODE_UPPER： $A$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $A$ 是下三角矩阵
transA [mublasOperation_t] 指定对矩阵 $A$ $A$ 的操作：
- MUBLAS_OP_N：解 $A \cdot x = b$
- MUBLAS_OP_T：解 $A^T \cdot x = b$
- MUBLAS_OP_C：解 $A^H \cdot x = b$
diag [mublasDiagType_t] 指定 $A$ $A$ 的对角线类型：
- MUBLAS_DIAG_UNIT：假设 $A$ 是单位三角（即， $A$ 的对角线元素在计算中不使用）
- MUBLAS_DIAG_NON_UNIT：不假设 $A$ 是单位三角
n [mublas_int] 指定 $b$ 的行数。 $n \geq 0$ 。
AP 存储紧凑版本的矩阵 $A$ 的设备指针，尺寸 $\geq \frac{n \cdot (n + 1)}{2}$ 。
x 存储输入向量 $b$ 的设备指针，被 $x$ 覆盖。
incx [mublas_int] 指定 $x$ 元素的增量。

操作

tpsv函数执行以下矩阵-向量操作：

$A \cdot x = b \quad \text{or} \quad A^T \cdot x = b \quad \text{or} \quad A^H \cdot x = b$

其中 $x$ 和 $b$ 是向量， $A$ 是以紧凑格式存储的三角矩阵。

输入向量 $b$ 被输出向量 $x$ 覆盖。

函数 mublasCtrmm

mublasStatus mublasCtrmm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    muComplex * B,
    mublas_int ldb
)

函数 mublasStrmm

mublasStatus mublasStrmm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const float * alpha,
    const float * A,
    mublas_int lda,
    float * B,
    mublas_int ldb
)

函数 mublasDtrmm

mublasStatus mublasDtrmm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const double * alpha,
    const double * A,
    mublas_int lda,
    double * B,
    mublas_int ldb
)

函数 mublasZtrmm

mublasStatus mublasZtrmm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * A,
    mublas_int lda,
    muDoubleComplex * B,
    mublas_int ldb
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
side [mublasSideMode_t] 指定op( $A$ $A$ )是否从左侧或右侧乘以 $B$ $B$ ：
- MUBLAS_SIDE_LEFT： $B := \alpha \cdot \text{op}( A ) \cdot B$
- MUBLAS_SIDE_RIGHT： $B := \alpha \cdot B \cdot \text{op}( A )$
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是否为上三角或下三角：
- MUBLAS_FILL_MODE_UPPER： $A$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $A$ 是下三角矩阵
transA [mublasOperation_t] 指定 $\text{op}(A)$ $op (A)$ 的形式，用于矩阵乘法：
- MUBLAS_OP_N： $\text{op}(A) = A$
- MUBLAS_OP_T： $\text{op}(A) = A^T$
- MUBLAS_OP_C： $\text{op}(A) = A^H$
diag [mublasDiagType_t] 指定 $A$ $A$ 是否为单位三角：
- MUBLAS_DIAG_UNIT：假设 $A$ 是单位三角
- MUBLAS_DIAG_NON_UNIT：不假设 $A$ 是单位三角
m [mublas_int] 指定 $B$ 的行数。 $m \geq 0$ 。
n [mublas_int] 指定 $B$ 的列数。 $n \geq 0$ 。
alpha 指定标量 $\alpha$ 。当 $\alpha = 0$ 时，不引用 $A$ ，且不需要在进入前设置 $B$ 。
A 指向GPU上的矩阵 $A$ 的设备指针。 $A$ 的尺寸为 $(\text{lda}, k)$ ，其中 $k$ 是 $m$ 当 $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ 时， $k$ 是 $n$ 当 $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$ 时。
lda [mublas_int] 指定 $A$ 的第一维度。如果 $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ ， $\text{lda} \geq \max( 1, m )$ ，如果 $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$ ， $\text{lda} \geq \max( 1, n )$ 。
B 指向GPU上的第一个矩阵 $B_0$ 的设备指针。进入时，数组 $B$ 的前 $m \times n$ 部分必须包含矩阵 $B$ ，退出时，被转换后的矩阵覆盖。
ldb [mublas_int] 指定 $B$ 的第一维度。 $\text{ldb} \geq \max( 1, m )$ 。

操作

trmm函数执行以下矩阵-矩阵操作之一：

$B := \alpha \cdot \text{op}( A ) \cdot B \quad \text{or} \quad B := \alpha \cdot B \cdot \text{op}( A )$

其中 $\alpha$ 是标量， $B$ 是 $m \times n$ 矩阵， $A$ 是单位或非单位上三角或下三角矩阵， $\text{op}( A )$ 是以下之一：

$\text{op}( A ) = A \quad \text{or} \quad \text{op}( A ) = A^T \quad \text{or} \quad \text{op}( A ) = A^H$

当 $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_UPPER}$ 时，数组 $A$ 的前 $k \times k$ 上三角部分必须包含上三角矩阵，且不引用 $A$ 的严格下三角部分。这里， $k$ 是 $m$ 当 $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ 时， $k$ 是 $n$ 当 $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$ 时。
当 $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_LOWER}$ 时，数组 $A$ 的前 $k \times k$ 下三角部分必须包含下三角矩阵，且不引用 $A$ 的严格上三角部分。这里， $k$ 是 $m$ 当 $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ 时， $k$ 是 $n$ 当 $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$ 时。

注意，当 $\text{diag} = \text{MUBLAS\_DIAG\_UNIT}$ 时，不引用 $A$ 的对角线元素，并假设为1。

函数 mublasCtrmmStridedBatched

mublasStatus mublasCtrmmStridedBatched(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    mublas_stride stride_A,
    muComplex * B,
    mublas_int ldb,
    mublas_stride stride_B,
    mublas_int batch_count
)

函数 mublasStrmmStridedBatched

mublasStatus mublasStrmmStridedBatched(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const float * alpha,
    const float * A,
    mublas_int lda,
    mublas_stride stride_A,
    float * B,
    mublas_int ldb,
    mublas_stride stride_B,
    mublas_int batch_count
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
side [mublasSideMode_t] 指定op( $A_i$ $A_{i}$ )是否从左侧或右侧乘以 $B_i$ $B_{i}$ ：
- MUBLAS_SIDE_LEFT： $B_i := \alpha \cdot \text{op}( A_i ) \cdot B_i$
- MUBLAS_SIDE_RIGHT： $B_i := \alpha \cdot B_i \cdot \text{op}( A_i )$
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是否为上三角或下三角：
- MUBLAS_FILL_MODE_UPPER： $A$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $A$ 是下三角矩阵
transA [mublasOperation_t] 指定 $\text{op}(A_i)$ $op (A_{i})$ 的形式，用于矩阵乘法：
- MUBLAS_OP_N： $\text{op}(A_i) = A_i$
- MUBLAS_OP_T： $\text{op}(A_i) = A_i^T$
- MUBLAS_OP_C： $\text{op}(A_i) = A_i^H$
diag [mublasDiagType_t] 指定 $A_i$ $A_{i}$ 是否为单位三角：
- MUBLAS_DIAG_UNIT：假设 $A_i$ 是单位三角
- MUBLAS_DIAG_NON_UNIT：不假设 $A_i$ 是单位三角
m [mublas_int] 指定 $B_i$ 的行数。 $m \geq 0$ 。
n [mublas_int] 指定 $B_i$ 的列数。 $n \geq 0$ 。
alpha 指定标量 $\alpha$ 。当 $\alpha = 0$ 时，不引用 $A_i$ ，且不需要在进入前设置 $B_i$ 。
A 指向GPU上的第一个矩阵 $A_0$ 的设备指针。每个 $A_i$ 的尺寸为 $(\text{lda}, k)$ ，其中 $k$ 是 $m$ 当 $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ 时， $k$ 是 $n$ 当 $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$ 时。
lda [mublas_int] 指定 $A$ 的第一维度。如果 $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ ， $\text{lda} \geq \max( 1, m )$ ，如果 $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$ ， $\text{lda} \geq \max( 1, n )$ 。
stride_A [mublas_stride] 指定一个矩阵( $A_i$ )到下一个矩阵( $A_{i+1}$ )的跨度。
B 指向GPU上的第一个矩阵 $B_0$ 的设备指针。进入时，数组 $B_i$ 的前 $m \times n$ 部分必须包含矩阵 $B_i$ ，退出时，被转换后的矩阵覆盖。
ldb [mublas_int] 指定 $B_i$ 的第一维度。 $\text{ldb} \geq \max( 1, m )$ 。
stride_B [mublas_stride] 指定一个矩阵( $B_i$ )到下一个矩阵( $B_{i+1}$ )的跨度。
batch_count [mublas_int] 指定批处理中的实例 $i$ 的数量。

操作

trmm_strided_batched函数执行以下步进批处理矩阵-矩阵操作：

$B_i := \alpha \cdot \text{op}( A_i ) \cdot B_i \quad \text{or} \quad B_i := \alpha \cdot B_i \cdot \text{op}( A_i ) \quad \text{for} \quad i = 0, 1, \dots, \text{batch\_count} - 1$

其中 $\alpha$ 是标量， $B_i$ 是 $m \times n$ 矩阵， $A_i$ 是单位或非单位上三角或下三角矩阵， $\text{op}( A_i )$ 是以下之一：

$\text{op}( A_i ) = A_i \quad \text{or} \quad \text{op}( A_i ) = A_i^T \quad \text{or} \quad \text{op}( A_i ) = A_i^H$

当 $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_UPPER}$ 时，数组 $A$ 的前 $k \times k$ 上三角部分必须包含上三角矩阵，且不引用 $A$ 的严格下三角部分。
当 $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_LOWER}$ 时，数组 $A$ 的前 $k \times k$ 下三角部分必须包含下三角矩阵，且不引用 $A$ 的严格上三角部分。

注意，当 $\text{diag} = \text{MUBLAS\_DIAG\_UNIT}$ 时，不引用 $A_i$ 的对角线元素，并假设为1。

函数 mublasStrmv

mublasStatus mublasStrmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const float * A,
    mublas_int lda,
    float * x,
    mublas_int incx
)

函数 mublasCtrmv

mublasStatus mublasCtrmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const muComplex * A,
    mublas_int lda,
    muComplex * x,
    mublas_int incx
)

函数 mublasDtrmv

mublasStatus mublasDtrmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const double * A,
    mublas_int lda,
    double * x,
    mublas_int incx
)

函数 mublasZtrmv

mublasStatus mublasZtrmv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const muDoubleComplex * A,
    mublas_int lda,
    muDoubleComplex * x,
    mublas_int incx
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是否为上三角或下三角：
- MUBLAS_FILL_MODE_UPPER： $A$ 是上三角矩阵
- MUBLAS_FILL_MODE_LOWER： $A$ 是下三角矩阵
transA [mublasOperation_t] 指定 $\text{op}(A)$ $op (A)$ 的形式，用于矩阵-向量操作：
- MUBLAS_OP_N： $\text{op}(A) = A$
- MUBLAS_OP_T： $\text{op}(A) = A^T$
- MUBLAS_OP_C： $\text{op}(A) = A^H$
diag [mublasDiagType_t] 指定 $A$ $A$ 是否为单位三角：
- MUBLAS_DIAG_UNIT：假设 $A$ 是单位三角
- MUBLAS_DIAG_NON_UNIT：不假设 $A$ 是单位三角
m [mublas_int] 指定 $A$ 的行数。 $m \geq 0$ 。
A 存储矩阵 $A$ 的设备指针，尺寸为 $(\text{lda}, m)$ 。
lda [mublas_int] 指定 $A$ 的领先维度。 $\text{lda} = \max( 1, m )$ 。
x 存储向量 $x$ 的设备指针。
incx [mublas_int] 指定 $x$ 元素的增量。

trmv执行以下矩阵-向量操作之一：

x = A \cdot x \quad \text{or} \quad x = A^T \cdot x,

其中 $x$ 是 $n$ 元素向量， $A$ 是 $n \times n$ 单位或非单位上三角或下三角矩阵。

向量 $x$ 被覆盖。

函数 mublasCtrsm

mublasStatus mublasCtrsm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * A,
    mublas_int lda,
    muComplex * B,
    mublas_int ldb
)

函数 mublasStrsm

mublasStatus mublasStrsm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const float * alpha,
    const float * A,
    mublas_int lda,
    float * B,
    mublas_int ldb
)

函数 mublasDtrsm

mublasStatus mublasDtrsm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const double * alpha,
    const double * A,
    mublas_int lda,
    double * B,
    mublas_int ldb
)

函数 mublasZtrsm

mublasStatus mublasZtrsm(
    mublasHandle_t handle,
    mublasSideMode_t side,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * A,
    mublas_int lda,
    muDoubleComplex * B,
    mublas_int ldb
)

BLAS Level 3 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
side [mublasSideMode_t] MUBLAS_SIDE_LEFT: $op(A) \cdot X = \alpha \cdot B$ 。MUBLAS_SIDE_RIGHT: $X \cdot op(A) = \alpha \cdot B$ 。
uplo [mublasFillMode_t] MUBLAS_FILL_MODE_UPPER: $A$ 是一个上三角矩阵。MUBLAS_FILL_MODE_LOWER: $A$ 是一个下三角矩阵。
transA [mublasOperation_t] MUBLAS_OP_N: $op(A) = A$ 。MUBLAS_OP_T: $op(A) = A^T$ 。MUBLAS_OP_C: $op(A) = A^H$ 。
diag [mublasDiagType_t] MUBLAS_DIAG_UNIT: 假定 $A$ 是一个单位三角矩阵。MUBLAS_DIAG_NON_UNIT: 不假定 $A$ 是一个单位三角矩阵。
m [mublas_int] $m$ 指定 $B$ 的行数。 $m \geq 0$ 。
n [mublas_int] $n$ 指定 $B$ 的列数。 $n \geq 0$ 。
alpha 设备指针或主机指针，指定标量 $\alpha$ 。当 $\alpha$ 为零时，则不引用 $A$ ，且在进入前不需要设置 $B$ 。
A 存储矩阵 $A$ 的设备指针，维度为 ( $\text{lda}$ , $k$ )，其中 $k$ 是 $m$ 当 MUBLAS_SIDE_LEFT 和是 $n$ 当 MUBLAS_SIDE_RIGHT。只访问上/下三角部分。
lda [mublas_int] $\text{lda}$ 指定 $A$ 的第一维度。如果 side = MUBLAS_SIDE_LEFT, $\text{lda} \geq \max( 1, m )$ ，如果 side = MUBLAS_SIDE_RIGHT, $\text{lda} \geq \max( 1, n )$ 。
B 存储矩阵 $B$ 的设备指针。
ldb [mublas_int] $\text{ldb}$ 指定 $B$ 的第一维度。 $\text{ldb} \geq \max( 1, m )$ 。

trsm 解决以下矩阵方程之一：

op(A) \cdot X = \alpha \cdot B \quad \text{或} \quad X \cdot op(A) = \alpha \cdot B,

其中 $\alpha$ 是一个标量， $X$ 和 $B$ 是 $m \times n$ 矩阵， $A$ 是一个三角矩阵， $op(A)$ 是以下之一：

op(A) = A \quad \text{or} \quad op(A) = A^T \quad \text{or} \quad op(A) = A^H.

矩阵 $X$ 覆盖在 $B$ 上。

关于内存分配的说明：当 trsm 启动时，如果 $k$ 能被内部块大小 128 整除，并且不超过 10 个这样的块，API 利用句柄中预分配的内存来提高整体性能。可以通过环境变量 WORKBUF_TRSM_B_CHNK 管理此内存。当此变量未设置时，用于临时存储的设备内存默认为 1 MB，可能导致分块，进而可能降低性能。在这种情况下，建议将 WORKBUF_TRSM_B_CHNK 设置为一次要使用的右手边的期望块数。

（其中 $k$ 是 $m$ 当 MUBLAS_SIDE_LEFT 和是 $n$ 当 MUBLAS_SIDE_RIGHT）

函数 mublasStrsv

mublasStatus mublasStrsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const float * A,
    mublas_int lda,
    float * x,
    mublas_int incx
)

函数 mublasDtrsv

mublasStatus mublasDtrsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const double * A,
    mublas_int lda,
    double * x,
    mublas_int incx
)

函数 mublasCtrsv

mublasStatus mublasCtrsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const muComplex * A,
    mublas_int lda,
    muComplex * x,
    mublas_int incx
)

函数 mublasZtrsv

mublasStatus mublasZtrsv(
    mublasHandle_t handle,
    mublasFillMode_t uplo,
    mublasOperation_t transA,
    mublasDiagType_t diag,
    mublas_int m,
    const muDoubleComplex * A,
    mublas_int lda,
    muDoubleComplex * x,
    mublas_int incx
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
uplo [mublasFillMode_t] 指定矩阵 $A$ $A$ 是上三角还是下三角：
- MUBLAS_FILL_MODE_UPPER: $A$ 是一个上三角矩阵
- MUBLAS_FILL_MODE_LOWER: $A$ 是一个下三角矩阵
transA [mublasOperation_t] 指定 $\text{op}(A)$ $op (A)$ 在矩阵-向量操作中的形式：
- MUBLAS_OP_N: $\text{op}(A) = A$
- MUBLAS_OP_T: $\text{op}(A) = A^T$
- MUBLAS_OP_C: $\text{op}(A) = A^H$
diag [mublasDiagType_t] 指定 $A$ $A$ 是否是单位三角：
- MUBLAS_DIAG_UNIT: 假定 $A$ 是单位三角矩阵
- MUBLAS_DIAG_NON_UNIT: 不假定 $A$ 是单位三角矩阵
m [mublas_int] 指定 $b$ 的行数。 $m \geq 0$ 。
A 存储矩阵 $A$ 的设备指针，维度为 $(\text{lda}, m)$ 。
lda [mublas_int] 指定 $A$ 的主维度。 $\text{lda} = \max( 1, m )$ 。
x 存储向量 $x$ 的设备指针。
incx [mublas_int] 指定 $x$ 中元素的增量。

trsv 解决：

A \cdot x = b \quad \text{或} \quad A^T \cdot x = b,

其中 $x$ 和 $b$ 是向量， $A$ 是一个三角矩阵。

向量 $x$ 覆盖在 $b$ 上。

函数 mublasSgemvBatched

mublasStatus mublasSgemvBatched(
    mublasHandle_t handle,
    mublasOperation_t trans,
    mublas_int m,
    mublas_int n,
    const float * alpha,
    const float *const A[],
    mublas_int lda,
    const float *const x[],
    mublas_int incx,
    const float * beta,
    float *const y[],
    mublas_int incy,
    mublas_int batch_count
)

BLAS Level 2 API

参数：

handle [mublasHandle_t] mublas库上下文队列的句柄。
trans [mublasOperation_t] 指示矩阵 $A_i$ 是否转置（共轭）。
m [mublas_int] 每个矩阵 $A_i$ 的行数。
n [mublas_int] 每个矩阵 $A_i$ 的列数。
alpha 设备指针或主机指针到标量 $\alpha$ 。
A 设备数组，存储每个矩阵 $A_i$ 的设备指针。
lda [mublas_int] 指定每个矩阵 $A_i$ 的主维度。
x 设备数组，存储每个向量 $x_i$ 的设备指针。
incx [mublas_int] 指定每个向量 $x_i$ 中元素的增量。
beta 设备指针或主机指针到标量 $\beta$ 。
y 设备数组，存储每个向量 $y_i$ 的设备指针。
incy [mublas_int] 指定每个向量 $y_i$ 中元素的增量。
batch_count [mublas_int] 批次中的实例数。

gemv_batched 执行一批矩阵-向量操作：

y_i := \alpha \cdot A_i \cdot x_i + \beta \cdot y_i \quad \text{或} \quad y_i := \alpha \cdot A_i^T \cdot x_i + \beta \cdot y_i \quad \text{或} \quad y_i := \alpha \cdot A_i^H \cdot x_i + \beta \cdot y_i,

其中 $(A_i, x_i, y_i)$ 是批次中的第 $i$ 个实例。 $\alpha$ 和 $\beta$ 是标量， $x_i$ 和 $y_i$ 是向量， $A_i$ 是一个 $m \times n$ 矩阵，对于 $i = 1, \dots, \text{batch\_count}$ 。

函数 mublasGetMathMode

mublasStatus mublasGetMathMode(
    mublasHandle_t handle,
    mublasMathMode_t * math_mode
)

检索当前数学模式。

函数 mublasSetMathMode

mublasStatus mublasSetMathMode(
    mublasHandle_t handle,
    mublasMathMode_t math_mode
)

设置数学模式。

函数 mublasGetVersion

mublasStatus mublasGetVersion(
    mublasHandle_t handle,
    int * version
)

检索 muBLAS 库的版本号。

函数 mublasCreate

mublasStatus mublasCreate(
    mublasHandle_t * handle
)

创建句柄

函数 mublasDestroy

mublasStatus mublasDestroy(
    mublasHandle_t handle
)

销毁句柄

函数 mublasSetStream

mublasStatus mublasSetStream(
    mublasHandle_t handle,
    MUstream stream
)

为句柄设置流

函数 mublasGetPointerMode

mublasStatus mublasGetPointerMode(
    mublasHandle_t handle,
    mublasPointerMode_t * pointer_mode
)

获取 mublasPointerMode_t

函数 mublasSetPointerMode

mublasStatus mublasSetPointerMode(
    mublasHandle_t handle,
    mublasPointerMode_t pointer_mode
)

设置 mublasPointerMode_t

函数 mublasGetMatrixAsync

mublasStatus mublasGetMatrixAsync(
    mublas_int rows,
    mublas_int cols,
    mublas_int elem_size,
    const void * a,
    mublas_int lda,
    void * b,
    mublas_int ldb,
    MUstream stream
)

从设备到主机异步复制矩阵

参数

rows [mublas_int]
矩阵的行数。
cols [mublas_int]
矩阵的列数。
elem_size [mublas_int]
矩阵中每个元素的字节数。
a
GPU上的矩阵指针。
lda [mublas_int]
指定 $A$ 的主维度，其中 $\text{lda} \geq \text{rows}$ 。
b
主机上的矩阵指针。
ldb [mublas_int]
指定 $B$ 的主维度，其中 $\text{ldb} \geq \text{rows}$ 。
stream
指定此传输请求排队的流。

mublasGetMatrixAsync 从设备内存异步复制矩阵到固定主机内存。

主机内存 必须使用 hipHostMalloc 分配。
如果主机内存未固定，则传输将同步进行。

函数 mublasGetError

mublasStatus mublasGetError(
    void 
)

此函数已弃用。

函数 mublasGetMatrix

mublasStatus mublasGetMatrix(
    mublas_int rows,
    mublas_int cols,
    mublas_int elem_size,
    const void * a,
    mublas_int lda,
    void * b,
    mublas_int ldb
)

从设备到主机复制矩阵

参数

rows [mublas_int]
矩阵的行数。
cols [mublas_int]
矩阵的列数。
elem_size [mublas_int]
矩阵中每个元素的字节数。
a
GPU上的矩阵指针。
lda [mublas_int]
指定 $A$ 的主维度，其中 $\text{lda} \geq \text{rows}$ 。
b
主机上的矩阵指针。
ldb [mublas_int]
指定 $B$ 的主维度，其中 $\text{ldb} \geq \text{rows}$ 。

函数 mublasShutdown

mublasStatus mublasShutdown(
    void 
)

此函数已弃用。

函数 mublasGetVector

mublasStatus mublasGetVector(
    mublas_int n,
    mublas_int elem_size,
    const void * x,
    mublas_int incx,
    void * y,
    mublas_int incy
)

从设备到主机复制向量

参数

n [mublas_int]
向量中的元素数。
elem_size [mublas_int]
向量中每个元素的字节数。
x
设备上的向量指针。
incx [mublas_int]
指定向量 $x$ 中元素的增量。
y
主机上的向量指针。
incy [mublas_int]
指定向量 $y$ 中元素的增量。

函数 mublasGetLoggerCallback

mublasStatus mublasGetLoggerCallback(
    mublasLogCallback * userCallback
)

此函数检索通过 mublasSetLoggerCallback() 安装的自定义用户定义回调函数的函数指针，否则为零。

参数：

userCallback 用户定义的回调函数指针。

函数 mublasGetProperty

mublasStatus mublasGetProperty(
    libraryPropertyType_t type,
    int * value
)

获取请求的属性值

函数 mublasSetMatrixAsync

mublasStatus mublasSetMatrixAsync(
    mublas_int rows,
    mublas_int cols,
    mublas_int elem_size,
    const void * a,
    mublas_int lda,
    void * b,
    mublas_int ldb,
    MUstream stream
)

从主机到设备异步复制矩阵

参数：

rows [mublas_int] 矩阵的行数
cols [mublas_int] 矩阵的列数
elem_size [mublas_int] 矩阵中每个元素的字节数
a 主机上的矩阵指针
lda [mublas_int] 指定 A 的主维度，lda >= rows
b GPU上的矩阵指针
ldb [mublas_int] 指定 B 的主维度，ldb >= rows
stream 指定此传输请求排队的流

mublasSetMatrixAsync 从固定主机内存异步复制矩阵到设备内存。主机上的内存必须使用 hipHostMalloc 分配，否则传输将同步进行。

函数 mublasSetMatrix

mublasStatus mublasSetMatrix(
    mublas_int rows,
    mublas_int cols,
    mublas_int elem_size,
    const void * a,
    mublas_int lda,
    void * b,
    mublas_int ldb
)

从主机到设备复制矩阵

参数：

rows [mublas_int] 矩阵的行数
cols [mublas_int] 矩阵的列数
elem_size [mublas_int] 矩阵中每个元素的字节数
a 主机上的矩阵指针
lda [mublas_int] 指定 A 的主维度，lda >= rows
b GPU上的矩阵指针
ldb [mublas_int] 指定 B 的主维度，ldb >= rows

函数 mublasGetVectorAsync

mublasStatus mublasGetVectorAsync(
    mublas_int n,
    mublas_int elem_size,
    const void * x,
    mublas_int incx,
    void * y,
    mublas_int incy,
    MUstream stream
)

从设备到主机异步复制向量

参数：

n [mublas_int] 向量中的元素数
elem_size [mublas_int] 矩阵中每个元素的字节数
x 设备上的向量指针
incx [mublas_int] 指定向量中元素的增量
y 主机上的向量指针
incy [mublas_int] 指定向量中元素的增量
stream 指定此传输请求排队的流

mublasGetVectorAsync 从固定主机内存异步复制向量到设备内存。主机上的内存必须使用 hipHostMalloc 分配，否则传输将同步进行。

函数 mublasFree

mublasStatus mublasFree(
    void* devicePtr
)

释放 devicePtr 指向的设备内存空间。

参数:

devicePtr 指向设备上的内存的指针

mublasFree 释放之前分配的设备内存。请确保传递给此函数的指针是通过适当的内存管理函数分配的。

函数 mublasSetAtomicsMode

mublasStatus mublasSetAtomicsMode(
    mublasHandle_t handle,
    mublasAtomicsMode_t atomics_mode
)

设置 mublasAtomicsMode_t

参数:

handle [mublasHandle_t] 指向 cuBLAS 库上下文的句柄
atomics_mode [mublasAtomicsMode_t] 要设置的原子模式

mublasSetAtomicsMode 配置指定 cuBLAS 句柄的原子操作模式。

mublasSetVectorAsync

函数 mublasGetAtomicsMode

mublasStatus mublasGetAtomicsMode(
    mublasHandle_t handle,
    mublasAtomicsMode_t* atomics_mode
)

获取 mublasAtomicsMode_t

参数:

handle [mublasHandle_t] 指向 cuBLAS 库上下文的句柄
atomics_mode [mublasAtomicsMode_t*] 指向存储检索到的原子模式的指针

mublasGetAtomicsMode 获取指定 cuBLAS 句柄的当前原子操作模式，并将其存储在提供的指针中。

函数 mublasGetmusartVersion

mublasStatus mublasGetmusartVersion(
    int* musartversion
)

获取 MUSA 运行时的版本

参数:

musartversion [int*] 指向存储检索到的 MUSA 运行时版本的指针

mublasGetmusartVersion 返回当前的 MUSA 运行时版本，并将其存储在提供的指针中。

函数 mublasSetVector

mublasStatus mublasSetVector(
    mublas_int n,
    mublas_int elem_size,
    const void* x,
    mublas_int incx,
    void* y,
    mublas_int incy
)

将向量从主机复制到设备

参数:

n [mublas_int] 向量中的元素数
elem_size [mublas_int] 矩阵中每个元素的字节数
x 指向主机上的向量的指针
incx [mublas_int] 指定向量元素的增量
y 指向设备上的向量的指针
incy [mublas_int] 指定向量元素的增量

函数 mublasInit

mublasStatus mublasInit()

此函数已弃用

mublasInit 不再推荐使用，并可能在未来版本中删除。

函数 mublasAlloc

mublasStatus mublasAlloc(
    int n,
    int elemSize,
    void** devicePtr
)

分配设备内存

参数:

n [int] 要分配的元素数量
elemSize [int] 每个元素的字节大小
devicePtr [void**] 指向分配的设备内存的指针

mublasAlloc 在设备上分配 n 个元素的内存，每个元素大小为 elemSize 字节，并将分配的内存指针存储在 devicePtr 中。

函数 mublasSetKernelStream

mublasStatus mublasSetKernelStream(
    mublasHandle_t handle,
    MUstream stream
)

为句柄设置流

参数:

handle [mublasHandle_t] 指向 cuBLAS 库上下文的句柄
stream [MUstream] 要为句柄设置的流

mublasSetKernelStream 为指定的 cuBLAS 句柄分配特定的流，确保与此句柄关联的所有操作在指定流中执行。

函数 mublasSetLoggerCallback

mublasStatus mublasSetLoggerCallback(
    mublasLogCallback userCallback
)

通过 muBLAS C 公共 API 安装自定义用户回调函数

参数:

userCallback [mublasLogCallback] 指向用户定义的回调函数的指针

mublasSetLoggerCallback 注册一个自定义日志回调函数，允许用户处理 muBLAS 库生成的日志消息。

函数 mublasLoggerConfigure

mublasStatus mublasLoggerConfigure(
    int logIsOn,
    int logToStdOut,
    int logToStdErr,
    const char* logFileName
)

在运行时配置日志记录

参数:

logIsOn [int] 启用或禁用日志记录的标志
logToStdOut [int] 启用或禁用标准输出日志
logToStdErr [int] 启用或禁用标准错误日志
logFileName [const char*] 存储日志的文件名

mublasLoggerConfigure 允许用户启用或禁用日志记录，指定日志输出目标，并定义日志文件名称。

函数 mublasGemmEx

mublasStatus mublasGemmEx(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const void * alpha,
    const void * a,
    musaDataType_t a_type,
    mublas_int lda,
    const void * b,
    musaDataType_t b_type,
    mublas_int ldb,
    const void * beta,
    void * c,
    musaDataType_t c_type,
    mublas_int ldc,
    mublasComputeType_t compute_type,
    mublasGemmAlgo_t algo
)

static inline mublasStatus mublasGemmEx(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const void * alpha,
    const void * a,
    musaDataType_t a_type,
    mublas_int lda,
    const void * b,
    musaDataType_t b_type,
    mublas_int ldb,
    const void * beta,
    void * c,
    musaDataType_t c_type,
    mublas_int ldc,
    musaDataType_t compute_type,
    mublasGemmAlgo_t algo
)

BLAS EX API

参数：

handle: [mublasHandle_t] mublas库上下文队列的句柄。
transA: [mublasOperation_t] 指定 $\text{op}(A)$ 的形式。
transB: [mublasOperation_t] 指定 $\text{op}(B)$ 的形式。
m: [mublas_int] 矩阵维度 $m$ 。
n: [mublas_int] 矩阵维度 $n$ 。
k: [mublas_int] 矩阵维度 $k$ 。
alpha: [const void *] 设备指针或主机指针，指定标量 $\alpha$ 。数据类型与 compute_type 相同。
a: [void *] 存储矩阵 $A$ 的设备指针。
a_type: [musaDataType_t] 指定矩阵 $A$ 的数据类型。
lda: [mublas_int] 指定 $A$ 的主维度。
b: [void *] 存储矩阵 $B$ 的设备指针。
b_type: [musaDataType_t] 指定矩阵 $B$ 的数据类型。
ldb: [mublas_int] 指定 $B$ 的主维度。
beta: [const void *] 设备指针或主机指针，指定标量 $\beta$ 。数据类型与 compute_type 相同。
c: [void *] 存储矩阵 $C$ 的设备指针。
c_type: [musaDataType_t] 指定矩阵 $C$ 的数据类型。
ldc: [mublas_int] 指定 $C$ 的主维度。
compute_type: 指定计算的数据类型。
algo: [mublasGemmAlgo_t] 枚举指定算法类型。

gemm_ex 执行以下矩阵-矩阵操作之一：

C = \alpha \cdot \text{op}(A) \cdot \text{op}(B) + \beta \cdot C,

其中 $\text{op}(X)$ 是以下之一：

\text{op}(X) = X, \quad \text{op}(X) = X^T, \quad \text{op}(X) = X^H,

$\alpha$ 和 $\beta$ 是标量。 $A$ 、 $B$ 和 $C$ 是矩阵，其中 $\text{op}(A)$ 是一个 $m \times k$ 矩阵， $\text{op}(B)$ 是一个 $k \times n$ 矩阵， $C$ 是一个 $m \times n$ 矩阵。

支持的类型：

compute_type	a_type / b_type	c_type
`MUSA_R_16F` 或 `MUBLAS_COMPUTE_16F`	`MUSA_R_16F`	`MUSA_R_16F`
`MUSA_R_32F` 或 `MUBLAS_COMPUTE_32F`	`MUSA_R_16F`	`MUSA_R_32F`
`MUBLAS_COMPUTE_32F_FAST_TF32`	`MUSA_R_32F`	`MUSA_R_32F`
`MUSA_R_16BF` 或 `MUBLAS_COMPUTE_32F`	`MUSA_R_16BF`	`MUSA_R_16BF`
`MUSA_R_32F` 或 `MUBLAS_COMPUTE_32F`	`MUSA_R_32F`	`MUSA_R_32F`
`MUSA_R_64F` 或 `MUBLAS_COMPUTE_64F`	`MUSA_R_64F`	`MUSA_R_64F`

函数 mublasGemmStridedBatchedEx

mublasStatus mublasGemmStridedBatchedEx(
    mublasHandle_t handle,
    mublasOperation_t transa,
    mublasOperation_t transb,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const void * alpha,
    const void * a,
    musaDataType_t a_type,
    mublas_int lda,
    mublas_stride stride_a,
    const void * b,
    musaDataType_t b_type,
    mublas_int ldb,
    mublas_stride stride_b,
    const void * beta,
    void * c,
    musaDataType_t c_type,
    mublas_int ldc,
    mublas_stride stride_c,
    mublas_int batch_count,
    mublasComputeType_t compute_type,
    mublasGemmAlgo_t algo
)

static inline mublasStatus mublasGemmStridedBatchedEx(
    mublasHandle_t handle,
    mublasOperation_t transa,
    mublasOperation_t transb,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const void * alpha,
    const void * a,
    musaDataType_t a_type,
    mublas_int lda,
    mublas_stride stride_a,
    const void * b,
    musaDataType_t b_type,
    mublas_int ldb,
    mublas_stride stride_b,
    const void * beta,
    void * c,
    musaDataType_t c_type,
    mublas_int ldc,
    mublas_stride stride_c,
    mublas_int batch_count,
    musaDataType_t compute_type,
    mublasGemmAlgo_t algo
)

BLAS EX API

参数：

handle [mublasHandle_t]：mublas库上下文队列的句柄。
transA [mublasOperation_t]：指定 $\text{op}(A)$ 的形式。
transB [mublasOperation_t]：指定 $\text{op}(B)$ 的形式。
m [mublas_int]： $\text{op}(A)$ 和 $C$ 的行数。
n [mublas_int]： $\text{op}(B)$ 和 $C$ 的列数。
k [mublas_int]： $\text{op}(A)$ 的列数和 $\text{op}(B)$ 的行数。
alpha [const void *]：设备或主机指针，指定标量 $\alpha$ 。必须与 compute_type 具有相同的数据类型。
a [const void *]：设备指针，指向第一个矩阵 $A_1$ 。
a_type [musaDataType_t]：指定每个矩阵 $A_i$ 的数据类型。
lda [mublas_int]：指定每个 $A_i$ 的主维度。
stride_a [mublas_stride]：从一个 $A_i$ 矩阵的开始到下一个 $A_{i+1}$ 的跨度。
b [const void *]：设备指针，指向第一个矩阵 $B_1$ 。
b_type [musaDataType_t]：指定每个矩阵 $B_i$ 的数据类型。
ldb [mublas_int]：指定每个 $B_i$ 的主维度。
stride_b [mublas_stride]：从一个 $B_i$ 矩阵的开始到下一个 $B_{i+1}$ 的跨度。
beta [const void *]：设备或主机指针，指定标量 $\beta$ 。必须与 compute_type 具有相同的数据类型。
c [void *]：设备指针，指向第一个矩阵 $C_1$ 。
c_type [musaDataType_t]：指定每个矩阵 $C_i$ 的数据类型。
ldc [mublas_int]：指定每个 $C_i$ 的主维度。
stride_c [mublas_stride]：从一个 $C_i$ 矩阵的开始到下一个 $C_{i+1}$ 的跨度。
batch_count [mublas_int]：批次中的 GEMM 操作数。
compute_type [mublasComputeType_t]：指定计算的数据类型。
algo [mublasGemmAlgo_t]：指定算法类型。

gemm_strided_batched_ex 执行以下跨批次矩阵-矩阵操作之一：

C_i = \alpha \cdot \text{op}(A_i) \cdot \text{op}(B_i) + \beta \cdot C_i, \quad \text{for } i = 1, \ldots, \text{batch\_count},

其中 $\text{op}(X)$ 是以下之一：

$\text{op}(X) = X$
$\text{op}(X) = X^T$
$\text{op}(X) = X^H$

$\alpha$ 和 $\beta$ 是标量， $A$ 、 $B$ 、 $C$ 是跨批次矩阵，其中：

$\text{op}(A)$ 是一个 $m \times k \times \text{batch\_count}$ 跨批次矩阵。
$\text{op}(B)$ 是一个 $k \times n \times \text{batch\_count}$ 跨批次矩阵。
$C$ 是一个 $m \times n \times \text{batch\_count}$ 跨批次矩阵。

跨批次矩阵是多个矩阵，由常数跨度分隔。矩阵的总数由 batch_count 指定。

支持的类型

以下类型受到支持：

compute_type	a_type / b_type	c_type
`MUSA_R_16F`, `MUBLAS_COMPUTE_16F`	`MUSA_R_16F`	`MUSA_R_16F`
`MUSA_R_32F`, `MUBLAS_COMPUTE_32F`	`MUSA_R_16F`	`MUSA_R_32F`
`MUBLAS_COMPUTE_32F_FAST_TF32`	`MUSA_R_32F`	`MUSA_R_32F`
`MUSA_R_16BF`, `MUBLAS_COMPUTE_32F`	`MUSA_R_16BF`	`MUSA_R_16BF`
`MUSA_R_32F`, `MUBLAS_COMPUTE_32F`	`MUSA_R_32F`	`MUSA_R_32F`
`MUBLAS_COMPUTE_64F`, `MUSA_R_64F`	`MUSA_R_64F`	`MUSA_R_64F`

函数 mublasGemmBatchedEx

mublasStatus mublasGemmBatchedEx(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const void * alpha,
    const void *const a[],
    musaDataType_t a_type,
    mublas_int lda,
    const void *const b[],
    musaDataType_t b_type,
    mublas_int ldb,
    const void * beta,
    void *const c[],
    musaDataType_t c_type,
    mublas_int ldc,
    mublas_int batch_count,
    mublasComputeType_t compute_type,
    mublasGemmAlgo_t algo
)

static inline mublasStatus mublasGemmBatchedEx(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const void * alpha,
    const void *const a[],
    musaDataType_t a_type,
    mublas_int lda,
    const void *const b[],
    musaDataType_t b_type,
    mublas_int ldb,
    const void * beta,
    void *const c[],
    musaDataType_t c_type,
    mublas_int ldc,
    mublas_int batch_count,
    musaDataType_t compute_type,
    mublasGemmAlgo_t algo
)

BLAS EX API

参数

handle [mublasHandle_t]
mublas库上下文队列的句柄。
transA [mublasOperation_t]
指定 $\text{op}(A)$ 的形式。
transB [mublasOperation_t]
指定 $\text{op}(B)$ 的形式。
m [mublas_int]
矩阵维度 $m$ 。
n [mublas_int]
矩阵维度 $n$ 。
k [mublas_int]
矩阵维度 $k$ 。
alpha [const void *]
设备指针或主机指针，指定标量 $\alpha$ 。与 compute_type 相同的数据类型。
a [void *]
设备指针，存储每个矩阵 $A_i$ 的指针数组。
a_type [musaDataType_t]
指定每个矩阵 $A_i$ 的数据类型。
lda [mublas_int]
指定每个 $A_i$ 的主维度。
b [void *]
设备指针，存储每个矩阵 $B_i$ 的指针数组。
b_type [musaDataType_t]
指定每个矩阵 $B_i$ 的数据类型。
ldb [mublas_int]
指定每个 $B_i$ 的主维度。
beta [const void *]
设备指针或主机指针，指定标量 $\beta$ 。与 compute_type 相同的数据类型。
c [void *]
设备指针数组，指向每个矩阵 $C_i$ 。
c_type [musaDataType_t]
指定每个矩阵 $C_i$ 的数据类型。
ldc [mublas_int]
指定每个 $C_i$ 的主维度。
batch_count [mublas_int]
批次中的 GEMM 操作数。
compute_type
指定计算的数据类型。
algo [mublasGemmAlgo_t]
枚举指定算法类型。

GemmBatchedEx 执行以下批次矩阵-矩阵操作之一：

C_i = \alpha \cdot \text{op}(A_i) \cdot \text{op}(B_i) + \beta \cdot C_i, \quad \text{for } i = 1, \dots, \text{batch\_count}.

其中：

$\text{op}(X)$ 是以下之一：
- $\text{op}(X) = X$ ,
- $\text{op}(X) = X^T$ , 或
- $\text{op}(X) = X^H$ .
$\alpha$ 和 $\beta$ 是标量。
$A$ 、 $B$ 和 $C$ 是批次矩阵指针：
- $\text{op}(A)$ 是一个 $m \times k \times \text{batch\_count}$ 批次矩阵，
- $\text{op}(B)$ 是一个 $k \times n \times \text{batch\_count}$ 批次矩阵，
- $C$ 是一个 $m \times n \times \text{batch\_count}$ 批次矩阵。

批次矩阵存储为指针数组，指针数量等于 $\text{batch\_count}$ 。

支持的类型

compute_type	a_type / b_type	c_type
`MUSA_R_16F`, `MUBLAS_COMPUTE_16F`	`MUSA_R_16F`	`MUSA_R_16F`
`MUSA_R_32F`, `MUBLAS_COMPUTE_32F`	`MUSA_R_16F`	`MUSA_R_32F`
`MUBLAS_COMPUTE_32F_FAST_TF32`	`MUSA_R_32F`	`MUSA_R_32F`
`MUSA_R_16BF`, `MUBLAS_COMPUTE_32F`	`MUSA_R_16BF`	`MUSA_R_16BF`
`MUSA_R_32F`, `MUBLAS_COMPUTE_32F`	`MUSA_R_32F`	`MUSA_R_32F`
`MUBLAS_COMPUTE_64F`, `MUSA_R_64F`	`MUSA_R_64F`	`MUSA_R_64F`

这篇文章对您有帮助吗？

摩尔线程和摩尔线程徽标是摩尔线程智能科技 (北京)有限责任公司的注册商标。

免责声明

本文档提供有关摩尔线程产品的信息。本文档并未授权任何知识产权的许可，并未以明示或暗示，或以禁止反言或其他方式授予任何知识产权许可。

函数

函数​

函数 mublasIsamax​

函数 mublasIdamax​

函数 mublasIzamax​

BLAS 一级 API​

函数 mublasIcamax​

BLAS 一级 API​

函数 mublasIsamin​

函数 mublasIdamin​

函数 mublasIzamin​

BLAS 一级 API​

函数 mublasIcamin​

BLAS 一级 API​

函数 mublasSasum​

函数 mublasDasum​

函数 mublasDzasum​

BLAS 一级 API​

函数 mublasScasum​

BLAS 一级 API​

函数 mublasSaxpy​

函数 mublasDaxpy​

函数 mublasZaxpy​

BLAS 一级 API​

函数 mublasCaxpy​

BLAS 一级 API​

函数 mublasCcopy​

BLAS 一级 API​

函数 mublasScopy​

函数 mublasDcopy​

函数 mublasZcopy​

BLAS 一级 API​

函数 mublasSdot​

函数 mublasZdotc​

函数 mublasDdot​

函数 mublasZdotu​

BLAS 一级 API​

函数 mublasCdotu​

函数 mublasCgbmv​

BLAS 二级 API​

示例​

函数 mublasSgbmv​

函数 mublasDgbmv​

函数 mublasZgbmv​

BLAS 二级 API​

函数 mublasZher2k​

BLAS Level 3 API​

操作​

函数 mublasCherk​

函数 mublasZherk​

BLAS Level 3 API​

操作​

函数 mublasCherkStridedBatched​

BLAS Level 3 API​

操作​

函数 mublasChpmv​

函数 mublasZhpmv​

BLAS Level 2 API​

操作​

函数 mublasChpr​

函数 mublasZhpr​

BLAS Level 2 API​

操作​

函数 mublasChpr2​

函数 mublasZhpr2​

BLAS Level 2 API​

操作​

函数 mublasSnrm2​

函数 mublasScnrm2​

函数 mublasDznrm2​

函数 mublasDnrm2​

BLAS Level 1 API​

操作​

函数 mublasSrot​

函数 mublasCsrot​

函数 mublasDrot​

函数 mublasZdrot​

BLAS Level 1 API​

操作​

函数 mublasSrotg​

函数 mublasCrotg​

函数

函数 mublasIsamax

函数 mublasIdamax

函数 mublasIzamax

BLAS 一级 API

函数 mublasIcamax

BLAS 一级 API

函数 mublasIsamin

函数 mublasIdamin

函数 mublasIzamin

BLAS 一级 API

函数 mublasIcamin

BLAS 一级 API

函数 mublasSasum

函数 mublasDasum

函数 mublasDzasum

BLAS 一级 API

函数 mublasScasum

BLAS 一级 API

函数 mublasSaxpy

函数 mublasDaxpy

函数 mublasZaxpy

BLAS 一级 API

函数 mublasCaxpy

BLAS 一级 API

函数 mublasCcopy

BLAS 一级 API

函数 mublasScopy

函数 mublasDcopy

函数 mublasZcopy

BLAS 一级 API

函数 mublasSdot

函数 mublasZdotc

函数 mublasDdot

函数 mublasZdotu

BLAS 一级 API

函数 mublasCdotu

函数 mublasCgbmv

BLAS 二级 API

示例

函数 mublasSgbmv

函数 mublasDgbmv

函数 mublasZgbmv

BLAS 二级 API

函数 mublasZher2k

BLAS Level 3 API

操作

函数 mublasCherk

函数 mublasZherk

BLAS Level 3 API

操作

函数 mublasCherkStridedBatched

BLAS Level 3 API

操作

函数 mublasChpmv

函数 mublasZhpmv

BLAS Level 2 API

操作

函数 mublasChpr

函数 mublasZhpr

BLAS Level 2 API

操作

函数 mublasChpr2

函数 mublasZhpr2

BLAS Level 2 API

操作

函数 mublasSnrm2

函数 mublasScnrm2

函数 mublasDznrm2

函数 mublasDnrm2

BLAS Level 1 API

操作

函数 mublasSrot

函数 mublasCsrot

函数 mublasDrot

函数 mublasZdrot

BLAS Level 1 API

操作

函数 mublasSrotg

函数 mublasCrotg