muBLAS API Reference

Functions

function mublasIsamax

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

function mublasIdamax

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

function mublasIzamax

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of y.
• result device pointer or host pointer to store the amax index. return is 0.0 if n, incx <= 0.

amax finds the first index of the element of maximum magnitude of a vector x. vector

function mublasIcamax

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] number of elements in each vector x_i
• x device array of device pointers storing each vector x_i.
• incx [mublas_int] specifies the increment for the elements of each x_i. incx must be > 0.
• batch_count [mublas_int] number of instances in the batch, must be > 0.
• result device or host array of pointers of batch_count size for results. return is 0 if n, incx<=0.

amax_batched finds the first index of the element of maximum magnitude of each vector x_i in a batch, for i = 1, ..., batch_count.

function mublasIsamin

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

function mublasIdamin

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

function mublasIzamin

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of y.
• result device pointer or host pointer to store the amin index. return is 0.0 if n, incx<=0.

amin finds the first index of the element of minimum magnitude of a vector x.

vector

function mublasIcamin

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] number of elements in each vector x_i
• x device array of device pointers storing each vector x_i.
• incx [mublas_int] specifies the increment for the elements of each x_i. incx must be > 0.
• batch_count [mublas_int] number of instances in the batch, must be > 0.
• result device or host pointers to array of batch_count size for results. return is 0 if n, incx<=0.

amin_batched finds the first index of the element of minimum magnitude of each vector x_i in a batch, for i = 1, ..., batch_count.

function mublasSasum

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

function mublasDasum

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

function mublasDzasum

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x and y.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x. incx must be > 0.
• result device pointer or host pointer to store the asum product. return is 0.0 if n <= 0.

asum computes the sum of the magnitudes of elements of a real vector x, or the sum of magnitudes of the real and imaginary parts of elements if x is a complex vector

function mublasScasum

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x and y.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x. incx must be > 0.
• result device pointer or host pointer to store the asum product. return is 0.0 if n <= 0.

asum computes the sum of the magnitudes of elements of a real vector x, or the sum of magnitudes of the real and imaginary parts of elements if x is a complex vector

function mublasSaxpy

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

function mublasDaxpy

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

function mublasZaxpy

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x and y.
• alpha device pointer or host pointer to specify the scalar alpha.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x.
• y device pointer storing vector y.
• incy [mublas_int] specifies the increment for the elements of y.

axpy computes constant alpha multiplied by vector x, plus vector y

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

function mublasCaxpy

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x and y.
• alpha device pointer or host pointer to specify the scalar alpha.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x.
• y device pointer storing vector y.
• incy [mublas_int] specifies the increment for the elements of y.

axpy computes constant alpha multiplied by vector x, plus vector y

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

function mublasCcopy

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x to be copied to y.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x.
• y device pointer storing vector y.
• incy [mublas_int] specifies the increment for the elements of y.

copy copies each element $x[i]$ into $y[i]$, for $i = 1, \dots, n$.

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

function mublasScopy

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

function mublasDcopy

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

function mublasZcopy

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x to be copied to y.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x.
• y device pointer storing vector y.
• incy [mublas_int] specifies the increment for the elements of y.

copy copies each element x[i] into y[i], for i = 1 , ... , n

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

function mublasSdot

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

function mublasZdotc

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

function mublasDdot

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

function mublasZdotu

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x and y.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x.
• y device pointer storing vector y.
• incy [mublas_int] specifies the increment for the elements of y.
• result device pointer or host pointer to store the dot product. Return is 0.0 if $n \leq 0$.

dot(u) performs the dot product of vectors x and y:

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

dotc performs the dot product of the conjugate of complex vector x and complex vector y:

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

function mublasCdotu

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

BLAS Level 1 API.

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x and y.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x.
• y device pointer storing vector y.
• incy [mublas_int] specifies the increment for the elements of y.
• result device pointer or host pointer to store the dot product. Return is 0.0 if $n \leq 0$.

dot(u) performs the dot product of vectors x and y:

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

dotc performs the dot product of the conjugate of complex vector x and complex vector y:

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

function 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 Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• trans: [mublasOperation_t] Indicates whether matrix $A$ is transposed (conjugated) or not.
• m: [mublas_int] Number of rows of matrix $A$.
• n: [mublas_int] Number of columns of matrix $A$.
• kl: [mublas_int] Number of sub-diagonals of $A$.
• ku: [mublas_int] Number of super-diagonals of $A$.
• alpha: Device pointer or host pointer to scalar $\alpha$.
• A: Device pointer storing banded matrix $A$. The matrix contains coefficients in a leading $(kl + ku + 1)$ by $n$ part. The leading diagonal resides in row $(ku + 1)$, the first super-diagonal on the RHS of row $ku$, and the first sub-diagonal on the LHS of row $ku + 2$. The structure propagates up and down across sub/super-diagonals.
• lda: [mublas_int] Leading dimension of $A$. Must be $\geq (kl + ku + 1)$.
• x: Device pointer storing vector $\mathbf{x}$.
• incx: [mublas_int] Specifies the increment for the elements of $\mathbf{x}$.
• beta: Device pointer or host pointer to scalar $\beta$.
• y: Device pointer storing vector $\mathbf{y}$.
• incy: [mublas_int] Specifies the increment for the elements of $\mathbf{y}$.

The gbmv function performs one of the following matrix-vector operations:

$$\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},$$

Where:

• $\alpha$ and $\beta$ are scalars.
• $\mathbf{x}$ and $\mathbf{y}$ are vectors.
• $A$ is an $m \times n$ banded matrix with $k_l$ sub-diagonals and $k_u$ super-diagonals.

Example

For example, when $m = n = 7$, $ku = 2$, and $kl = 2$:

Matrix $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}$$

The matrix will be stored in a compressed format, considering the sub- and super-diagonals. Empty elements, which do not correspond to data, will not be referenced.

function 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
)

function 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
)

function 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 Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• trans: [mublasOperation_t] Indicates whether matrix $A$ is transposed (conjugated) or not.
• m: [mublas_int] Number of rows of matrix $A$.
• n: [mublas_int] Number of columns of matrix $A$.
• kl: [mublas_int] Number of sub-diagonals of $A$.
• ku: [mublas_int] Number of super-diagonals of $A$.
• alpha: Device pointer or host pointer to scalar $\alpha$.
• A: Device pointer storing banded matrix $A$. The matrix contains coefficients in a leading $(kl + ku + 1) \times n$ part. The leading diagonal resides in row $(ku + 1)$, the first super-diagonal on the RHS of row $ku$, and the first sub-diagonal on the LHS of row $ku + 2$. The structure propagates up and down across sub/super-diagonals.
• lda: [mublas_int] Leading dimension of $A$. Must be $\geq (kl + ku + 1)$.
• x: Device pointer storing vector $\mathbf{x}$.
• incx: [mublas_int] Specifies the increment for the elements of $\mathbf{x}$.
• beta: Device pointer or host pointer to scalar $\beta$.
• y: Device pointer storing vector $\mathbf{y}$.
• incy: [mublas_int] Specifies the increment for the elements of $\mathbf{y}$.

Operation

The gbmv function performs one of the following matrix-vector operations:

$$\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},$$

Where:

• $\alpha$ and $\beta$ are scalars.
• $\mathbf{x}$ and $\mathbf{y}$ are vectors.
• $A$ is an $m \times n$ banded matrix with $k_l$ sub-diagonals and $k_u$ super-diagonals.

function mublasCgemm

mublasStatus mublasCgemm(
    mublasHandle_t    handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int        m,
    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
)

function mublasSgemm

mublasStatus mublasSgemm(
    mublasHandle_t    handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int        m,
    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
)

function mublasZgemm

mublasStatus mublasZgemm(
    mublasHandle_t          handle,
    mublasOperation_t       transA,
    mublasOperation_t       transB,
    mublas_int              m,
    mublas_int              n,
    mublas_int              k,
    const muDoubleComplex*  alpha,
    const muDoubleComplex*  A,
    mublas_int              lda,
    const muDoubleComplex*  B,
    mublas_int              ldb,
    const muDoubleComplex*  beta,
    muDoubleComplex*        C,
    mublas_int              ldc
)

function mublasDgemm

mublasStatus mublasDgemm(
    mublasHandle_t    handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int        m,
    mublas_int        n,
    mublas_int        k,
    const double*     alpha,
    const double*     A,
    mublas_int        lda,
    const double*     B,
    mublas_int        ldb,
    const double*     beta,
    double*           C,
    mublas_int        ldc
)

BLAS Level 3 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• transA: [mublasOperation_t] Specifies the form of $\text{op}( A )$.
• transB: [mublasOperation_t] Specifies the form of $\text{op}( B )$.
• m: [mublas_int] Number of rows of matrices $\text{op}( A )$ and $C$.
• n: [mublas_int] Number of columns of matrices $\text{op}( B )$ and $C$.
• k: [mublas_int] Number of columns of matrix $\text{op}( A )$ and number of rows of matrix $\text{op}( B )$.
• alpha: Device pointer or host pointer specifying the scalar $\alpha$.
• A: Device pointer storing matrix $A$.
• lda: [mublas_int] Specifies the leading dimension of $A$.
• B: Device pointer storing matrix $B$.
• ldb: [mublas_int] Specifies the leading dimension of $B$.
• beta: Device pointer or host pointer specifying the scalar $\beta$.
• C: Device pointer storing matrix $C$ on the GPU.
• ldc: [mublas_int] Specifies the leading dimension of $C$.

Operation

The gemm function performs one of the following matrix-matrix operations:

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

Where $\text{op}( X )$ is one of:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $A$, $B$, and $C$ are matrices, with $\text{op}( A )$ being an $m \times k$ matrix, $\text{op}( B )$ being a $k \times n$ matrix, and $C$ being an $m \times n$ matrix.

function mublasCgemmBatched

mublasStatus mublasCgemmBatched(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const muComplex * alpha,
    const muComplex *const A[],
    mublas_int lda,
    const muComplex *const B[],
    mublas_int ldb,
    const muComplex * beta,
    muComplex *const C[],
    mublas_int ldc,
    mublas_int batch_count
)

function mublasSgemmBatched

mublasStatus mublasSgemmBatched(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const float * alpha,
    const float *const A[],
    mublas_int lda,
    const float *const B[],
    mublas_int ldb,
    const float * beta,
    float *const C[],
    mublas_int ldc,
    mublas_int batch_count
)

function mublasZgemmBatched

mublasStatus mublasZgemmBatched(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const muDoubleComplex * alpha,
    const muDoubleComplex *const A[],
    mublas_int lda,
    const muDoubleComplex *const B[],
    mublas_int ldb,
    const muDoubleComplex * beta,
    muDoubleComplex *const C[],
    mublas_int ldc,
    mublas_int batch_count
)

function mublasDgemmBatched

mublasStatus mublasDgemmBatched(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    const double * alpha,
    const double *const A[],
    mublas_int lda,
    const double *const B[],
    mublas_int ldb,
    const double * beta,
    double *const C[],
    mublas_int ldc,
    mublas_int batch_count
)

BLAS Level 3 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• transA: [mublasOperation_t] Specifies the form of $\text{op}( A )$.
• transB: [mublasOperation_t] Specifies the form of $\text{op}( B )$.
• m: [mublas_int] Matrix dimension $m$.
• n: [mublas_int] Matrix dimension $n$.
• k: [mublas_int] Matrix dimension $k$.
• alpha: Device pointer or host pointer specifying the scalar $\alpha$.
• A: Device array of device pointers storing each matrix $A_i$.
• lda: [mublas_int] Specifies the leading dimension of each $A_i$.
• B: Device array of device pointers storing each matrix $B_i$.
• ldb: [mublas_int] Specifies the leading dimension of each $B_i$.
• beta: Device pointer or host pointer specifying the scalar $\beta$.
• C: Device array of device pointers storing each matrix $C_i$.
• ldc: [mublas_int] Specifies the leading dimension of each $C_i$.
• batch_count: [mublas_int] Number of GEMM operations in the batch.

Operation

The gemm_batched function performs one of the batched matrix-matrix operations:

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

Where $\text{op}( X )$ is one of:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $A$, $B$, and $C$ are strided batched matrices:
  • $\text{op}( A )$ is an $m \times k$ by batch_count strided-batched matrix.
  • $\text{op}( B )$ is a $k \times n$ by batch_count strided-batched matrix.
  • $C$ is an $m \times n$ by batch_count strided-batched matrix.

function mublasCgemmStridedBatched

mublasStatus mublasCgemmStridedBatched(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    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
)

function mublasSgemmStridedBatched

mublasStatus mublasSgemmStridedBatched(
    mublasHandle_t handle,
    mublasOperation_t transA,
    mublasOperation_t transB,
    mublas_int m,
    mublas_int n,
    mublas_int k,
    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
)

BLAS Level 3 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• transA: [mublasOperation_t] Specifies the form of $\text{op}( A )$.
• transB: [mublasOperation_t] Specifies the form of $\text{op}( B )$.
• m: [mublas_int] Matrix dimension $m$.
• n: [mublas_int] Matrix dimension $n$.
• k: [mublas_int] Matrix dimension $k$.
• alpha: Device pointer or host pointer specifying the scalar $\alpha$.
• A: Device pointer pointing to the first matrix $A_1$.
• lda: [mublas_int] Specifies the leading dimension of each $A_i$.
• stride_a: [mublas_stride] Stride from the start of one $A*i$ matrix to the next $A*{i+1}$.
• B: Device pointer pointing to the first matrix $B_1$.
• ldb: [mublas_int] Specifies the leading dimension of each $B_i$.
• stride_b: [mublas_stride] Stride from the start of one $B*i$ matrix to the next $B*{i+1}$.
• beta: Device pointer or host pointer specifying the scalar $\beta$.
• C: Device pointer pointing to the first matrix $C_1$.
• ldc: [mublas_int] Specifies the leading dimension of each $C_i$.
• stride_c: [mublas_stride] Stride from the start of one $C*i$ matrix to the next $C*{i+1}$.
• batch_count: [mublas_int] Number of GEMM operations in the batch.

Operation

The gemm_strided_batched function performs one of the strided batched matrix-matrix operations:

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

Where $\text{op}( X )$ is one of:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $A$, $B$, and $C$ are strided batched matrices:
  • $\text{op}( A )$ is an $m \times k$ by batch_count strided-batched matrix.
  • $\text{op}( B )$ is a $k \times n$ by batch_count strided-batched matrix.
  • $C$ is an $m \times n$ by batch_count strided-batched matrix.

function mublasCgemv

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

function mublasSgemv

mublasStatus mublasSgemv(
    mublasHandle_t handle,
    mublasOperation_t trans,
    mublas_int m,
    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
)

function mublasDgemv

mublasStatus mublasDgemv(
    mublasHandle_t handle,
    mublasOperation_t trans,
    mublas_int m,
    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
)

function mublasZgemv

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

BLAS Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• trans: [mublasOperation_t] Indicates whether matrix $A$ is transposed (conjugated) or not.
• m: [mublas_int] Number of rows of matrix $A$.
• n: [mublas_int] Number of columns of matrix $A$.
• alpha: Device pointer or host pointer to scalar $\alpha$.
• A: Device pointer storing matrix $A$.
• lda: [mublas_int] Specifies the leading dimension of $A$.
• x: Device pointer storing vector $\mathbf{x}$.
• incx: [mublas_int] Specifies the increment for the elements of $\mathbf{x}$.
• beta: Device pointer or host pointer to scalar $\beta$.
• y: Device pointer storing vector $\mathbf{y}$.
• incy: [mublas_int] Specifies the increment for the elements of $\mathbf{y}$.

Operation

The gemv function performs one of the following matrix-vector operations:

$$\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},$$

Where:

• $\alpha$ and $\beta$ are scalars.
• $\mathbf{x}$ and $\mathbf{y}$ are vectors.
• $A$ is an $m \times n$ matrix.

function mublasSger

mublasStatus mublasSger(
    mublasHandle_t handle,
    mublas_int m,
    mublas_int n,
    const float * alpha,
    const float * x,
    mublas_int incx,
    const float * y,
    mublas_int incy,
    float * A,
    mublas_int lda
)

function mublasDger

mublasStatus mublasDger(
    mublasHandle_t handle,
    mublas_int m,
    mublas_int n,
    const double * alpha,
    const double * x,
    mublas_int incx,
    const double * y,
    mublas_int incy,
    double * A,
    mublas_int lda
)

function mublasCgeru

mublasStatus mublasCgeru(
    mublasHandle_t handle,
    mublas_int m,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * x,
    mublas_int incx,
    const muComplex * y,
    mublas_int incy,
    muComplex * A,
    mublas_int lda
)

function mublasZgeru

mublasStatus mublasZgeru(
    mublasHandle_t handle,
    mublas_int m,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * x,
    mublas_int incx,
    const muDoubleComplex * y,
    mublas_int incy,
    muDoubleComplex * A,
    mublas_int lda
)

function mublasCgerc

mublasStatus mublasCgerc(
    mublasHandle_t handle,
    mublas_int m,
    mublas_int n,
    const muComplex * alpha,
    const muComplex * x,
    mublas_int incx,
    const muComplex * y,
    mublas_int incy,
    muComplex * A,
    mublas_int lda
)

function mublasZgerc

mublasStatus mublasZgerc(
    mublasHandle_t handle,
    mublas_int m,
    mublas_int n,
    const muDoubleComplex * alpha,
    const muDoubleComplex * x,
    mublas_int incx,
    const muDoubleComplex * y,
    mublas_int incy,
    muDoubleComplex * A,
    mublas_int lda
)

BLAS Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• m: [mublas_int] The number of rows of the matrix $A$.
• n: [mublas_int] The number of columns of the matrix $A$.
• alpha: Device pointer or host pointer to scalar $\alpha$.
• x: Device pointer storing vector $\mathbf{x}$.
• incx: [mublas_int] Specifies the increment for the elements of $\mathbf{x}$.
• y: Device pointer storing vector $\mathbf{y}$.
• incy: [mublas_int] Specifies the increment for the elements of $\mathbf{y}$.
• A: Device pointer storing matrix $A$.
• lda: [mublas_int] Specifies the leading dimension of $A$.

Operation

The ger, geru, and gerc functions perform the following matrix-vector operations:

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

Where:

• $\alpha$ is a scalar.
• $\mathbf{x}$ and $\mathbf{y}$ are vectors.
• $A$ is an $m \times n$ matrix.

function mublasChbmv

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

function mublasZhbmv

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

BLAS Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of A is being supplied.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of A is being supplied.
• n: [mublas_int] The order of the matrix $A$.
• k: [mublas_int] The number of super-diagonals of the matrix $A$. Must be >= 0.
• alpha: Device pointer or host pointer to scalar $\alpha$.
• A: Device pointer storing matrix $A$. Dimension is $(\text{lda}, n)$.
  • If uplo == MUBLAS_FILL_MODE_UPPER: The leading $(k + 1) \times n$ part of A contains the upper triangular band part of the Hermitian matrix, with the leading diagonal in row $(k + 1)$, the first super-diagonal on the RHS of row $k$, and so on.
  • If uplo == MUBLAS_FILL_MODE_LOWER: The leading $(k + 1) \times n$ part of A contains the lower triangular band part of the Hermitian matrix, with the leading diagonal in row 1, the first sub-diagonal on the LHS of row 2, and so on.
• lda: [mublas_int] Specifies the leading dimension of $A$. Must be >= $k + 1$.
• x: Device pointer storing vector $\mathbf{x}$.
• incx: [mublas_int] Specifies the increment for the elements of $\mathbf{x}$.
• beta: Device pointer or host pointer to scalar $\beta$.
• y: Device pointer storing vector $\mathbf{y}$.
• incy: [mublas_int] Specifies the increment for the elements of $\mathbf{y}$.

Operation

The hbmv function performs the following matrix-vector operation:

$$\mathbf{y} := \alpha \cdot A \cdot \mathbf{x} + \beta \cdot \mathbf{y},$$

Where:

• $\alpha$ and $\beta$ are scalars.
• $\mathbf{x}$ and $\mathbf{y}$ are vectors with $n$ elements.
• $A$ is an $n \times n$ Hermitian band matrix with $k$ super-diagonals.

If uplo == MUBLAS_FILL_MODE_UPPER, the matrix $A$ contains the upper triangular part of the Hermitian matrix. If uplo == MUBLAS_FILL_MODE_LOWER, the matrix $A$ contains the lower triangular part.

function mublasChemm

mublasStatus mublasChemm(
    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
)

function mublasZhemm

mublasStatus mublasZhemm(
    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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• 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$ is an upper triangular matrix.
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix.
• m: [mublas_int] The number of rows of $B$ and $C$. Must be $m \geq 0$.
• n: [mublas_int] The number of columns of $B$ and $C$. Must be $n \geq 0$.
• alpha: Scalar $\alpha$. If $\alpha = 0$, then $A$ and $B$ are not referenced.
• A: Pointer storing matrix $A$ on the GPU.
  • If side = MUBLAS_SIDE_LEFT: $A$ is $m \times m$.
  • If side = MUBLAS_SIDE_RIGHT: $A$ is $n \times n$.
  • Only the upper or lower triangular part of $A$ is accessed.
  • The imaginary part of the diagonal elements is not used.
• lda: [mublas_int] Specifies the first dimension of $A$.
  • If side = MUBLAS_SIDE_LEFT, $\text{lda} \geq \max(1, m)$.
  • If side = MUBLAS_SIDE_RIGHT, $\text{lda} \geq \max(1, n)$.
• B: Pointer storing matrix $B$ on the GPU. Matrix dimension is $m \times n$.
• ldb: [mublas_int] Specifies the first dimension of $B$. $\text{ldb} \geq \max(1, m)$.
• beta: Scalar $\beta$. If $\beta = 0$, then $C$ does not need to be set before entry.
• C: Pointer storing matrix $C$ on the GPU. Matrix dimension is $m \times n$.
• ldc: [mublas_int] Specifies the first dimension of $C$. $\text{ldc} \geq \max(1, m)$.

Operation

The hemm function performs the following matrix-matrix operation:

• If side == MUBLAS_SIDE_LEFT:

  $$C := \alpha A B + \beta C$$

• If side == MUBLAS_SIDE_RIGHT:

  $$C := \alpha B A + \beta C$$

Where:

• $\alpha$ and $\beta$ are scalars.
• $B$ and $C$ are $m \times n$ matrices.
• $A$ is a Hermitian matrix stored as either upper or lower triangular.

function mublasChemv

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

function mublasZhemv

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

BLAS Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of the Hermitian matrix $A$ is supplied.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of the Hermitian matrix $A$ is supplied.
• n: [mublas_int] The order of the matrix $A$.
• alpha: Scalar $\alpha$.
• A: Pointer storing matrix $A$.
  • If uplo == MUBLAS_FILL_MODE_UPPER: The upper triangular part of $A$ must contain the upper triangular part of a Hermitian matrix. The lower triangular part will not be referenced.
  • If uplo == MUBLAS_FILL_MODE_LOWER: The lower triangular part of $A$ must contain the lower triangular part of a Hermitian matrix. The upper triangular part will not be referenced.
  • The imaginary part of the main diagonal of $A$ is assumed to be zero (Hermitian matrix).
• lda: [mublas_int] Specifies the leading dimension of $A$. Must be $\geq \max(1, n)$.
• x: Pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• beta: Scalar $\beta$.
• y: Pointer storing vector $y$.
• incy: [mublas_int] Specifies the increment for the elements of $y$.

Operation

The hemv function performs the following matrix-vector operation:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $x$ and $y$ are $n$-element vectors.
• $A$ is an $n \times n$ Hermitian matrix, with the appropriate triangular part (upper or lower) referenced based on uplo.

function mublasCher

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

function mublasZher

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

BLAS Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of matrix $A$ is supplied.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of matrix $A$ is supplied.
• n: [mublas_int] The number of rows and columns of matrix $A$, must be at least 0.
• alpha: Scalar $\alpha$.
• x: Pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• A: Pointer storing the specified triangular portion of the Hermitian matrix $A$.
  • If uplo == MUBLAS_FILL_MODE_UPPER: The upper triangular portion of $A$ is supplied. The lower triangular portion will not be accessed.
  • If uplo == MUBLAS_FILL_MODE_LOWER: The lower triangular portion of $A$ is supplied. The upper triangular portion will not be accessed.
  • The imaginary part of the diagonal elements of $A$ is not accessed and is assumed to be 0 (Hermitian matrix).
• lda: [mublas_int] Specifies the leading dimension of $A$. Must be at least $\max(1, n)$.

Operation

The her function performs the following matrix-vector operation:

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

Where:

• $\alpha$ is a real scalar.
• $x$ is a vector.
• $A$ is an $n \times n$ Hermitian matrix.
• $x^H$ is the conjugate transpose of $x$.

function mublasCher2

mublasStatus mublasCher2(
    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 * A,
    mublas_int lda
)

function mublasZher2

mublasStatus mublasZher2(
    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 * A,
    mublas_int lda
)

BLAS Level 2 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of matrix $A$ is supplied.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of matrix $A$ is supplied.
• n: [mublas_int] The number of rows and columns of matrix $A$, must be at least 0.
• alpha: Scalar $\alpha$ (complex scalar).
• x: Pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• y: Pointer storing vector $y$.
• incy: [mublas_int] Specifies the increment for the elements of $y$.
• A: Pointer storing the specified triangular portion of the Hermitian matrix $A$.
  • If uplo == MUBLAS_FILL_MODE_UPPER: The upper triangular portion of $A$ is supplied. The lower triangular portion will not be accessed.
  • If uplo == MUBLAS_FILL_MODE_LOWER: The lower triangular portion of $A$ is supplied. The upper triangular portion will not be accessed.
  • The imaginary part of the diagonal elements of $A$ is not accessed and is assumed to be 0 (Hermitian matrix).
• lda: [mublas_int] Specifies the leading dimension of $A$. Must be at least $\max(\text{lda}, 1)$.

Operation

The her2 function performs the following matrix-vector operation:

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

Where:

• $\alpha$ is a complex scalar.
• $x$ and $y$ are vectors.
• $A$ is an $n \times n$ Hermitian matrix.
• $x^H$ and $y^H$ are the conjugate transposes of $x$ and $y$, respectively.
• $\overline{\alpha}$ denotes the complex conjugate of $\alpha$.

function mublasCher2k

mublasStatus mublasCher2k(
    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 float * beta,
    muComplex * C,
    mublas_int ldc
)

function 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] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: $C$ is an upper triangular matrix.
  • MUBLAS_FILL_MODE_LOWER: $C$ is a lower triangular matrix.
• 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] The number of rows and columns of matrix $C$. Must be $n \geq 0$.
• k: [mublas_int] The number of columns of $\text{op}(A)$. Must be $k \geq 0$.
• alpha: Scalar $\alpha$. When $\alpha = 0$, $A$ is not referenced, and $A$ need not be set before entry.
• A: Pointer storing matrix $A$ on the GPU. Matrix dimension is:
  • $(\text{lda}, k)$ when $trans = MUBLAS\_OP\_N$,
  • $(\text{lda}, n)$ when $trans = MUBLAS\_OP\_C$.
  • Only the upper/lower triangular part is accessed.
• lda: [mublas_int] The leading dimension of $A$.
  • If $trans = MUBLAS\_OP\_N$, $\text{lda} \geq \max(1, n)$.
  • Otherwise, $\text{lda} \geq \max(1, k)$.
• B: Pointer storing matrix $B$ on the GPU. Matrix dimension is:
  • $(\text{ldb}, k)$ when $trans = MUBLAS\_OP\_N$,
  • $(\text{ldb}, n)$ when $trans = MUBLAS\_OP\_C$.
  • Only the upper/lower triangular part is accessed.
• ldb: [mublas_int] The leading dimension of $B$.
  • If $trans = MUBLAS\_OP\_N$, $\text{ldb} \geq \max(1, n)$.
  • Otherwise, $\text{ldb} \geq \max(1, k)$.
• beta: Scalar $\beta$. When $\beta = 0$, $C$ need not be set before entry.
• C: Pointer storing matrix $C$ on the GPU. The imaginary part of the diagonal elements of $C$ is not accessed and is assumed to be 0 unless a quick return is performed.
• ldc: [mublas_int] The leading dimension of $C$. Must be $\text{ldc} \geq \max(1, n)$.

Operation

The her2k function performs the Hermitian rank-2k update for matrix-matrix operations:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $\text{op}(A)$ and $\text{op}(B)$ are $n \times k$ matrices.
• $C$ is an $n \times n$ Hermitian matrix.
• If $trans = MUBLAS\_OP\_N$, then $\text{op}(A) = A$ and $\text{op}(B) = B$.
• If $trans = MUBLAS\_OP\_C$, then $\text{op}(A) = A^H$ and $\text{op}(B) = B^H$.

function 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
)

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: $C$ is an upper triangular matrix.
  • MUBLAS_FILL_MODE_LOWER: $C$ is a lower triangular matrix.
• transA: [mublasOperation_t]
  • MUBLAS_OP_C: $\text{op}(A) = A^H$
  • MUBLAS_OP_N: $\text{op}(A) = A$
• n: [mublas_int] The number of rows and columns of matrix $C$. Must be $n \geq 0$.
• k: [mublas_int] The number of columns of $\text{op}(A)$. Must be $k \geq 0$.
• alpha: Scalar $\alpha$. When $\alpha = 0$, $A$ is not referenced, and $A$ need not be set before entry.
• A: Pointer storing matrix $A$ on the GPU. Matrix dimension is:
  • $(\text{lda}, k)$ when $transA = MUBLAS\_OP\_N$,
  • $(\text{lda}, n)$ when $transA = MUBLAS\_OP\_C$.
  • Only the upper/lower triangular part is accessed.
• lda: [mublas_int] The leading dimension of $A$.
  • If $transA = MUBLAS\_OP\_N$, $\text{lda} \geq \max(1, n)$.
  • Otherwise, $\text{lda} \geq \max(1, k)$.
• beta: Scalar $\beta$. When $\beta = 0$, $C$ need not be set before entry.
• C: Pointer storing matrix $C$ on the GPU. The imaginary component of the diagonal elements of $C$ is not accessed and is assumed to be 0 unless a quick return is performed.
• ldc: [mublas_int] The leading dimension of $C$. Must be $\text{ldc} \geq \max(1, n)$.

Operation

The herk function performs one of the matrix-matrix operations for a Hermitian rank-k update:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $\text{op}(A)$ is an $n \times k$ matrix.
• $C$ is an $n \times n$ Hermitian matrix stored as either upper or lower.
• If $trans = MUBLAS\_OP\_N$, then $\text{op}(A) = A$ and $A$ is $n \times k$.
• If $trans = MUBLAS\_OP\_C$, then $\text{op}(A) = A^H$ and $A$ is $k \times n$.

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: $C_i$ is an upper triangular matrix.
  • MUBLAS_FILL_MODE_LOWER: $C_i$ is a lower triangular matrix.
• transA: [mublasOperation_t]
  • MUBLAS_OP_C: $\text{op}(A) = A^H$
  • MUBLAS_OP_N: $\text{op}(A) = A$
• n: [mublas_int] The number of rows and columns of matrix $C_i$. Must be $n \geq 0$.
• k: [mublas_int] The number of columns of $\text{op}(A)$. Must be $k \geq 0$.
• alpha: Scalar $\alpha$. When $\alpha = 0$, $A$ is not referenced, and $A$ need not be set before entry.
• A: Device pointer to the first matrix $A_1$ on the GPU. Matrix dimension is:
  • $(\text{lda}, k)$ when $transA = MUBLAS\_OP\_N$.
  • $(\text{lda}, n)$ when $transA = MUBLAS\_OP\_C$.
• lda: [mublas_int] The leading dimension of $A_i$.
  • If $transA = MUBLAS\_OP\_N$, $\text{lda} \geq \max(1, n)$.
  • Otherwise, $\text{lda} \geq \max(1, k)$.
• stride_A: [mublas_stride] The stride from the start of one matrix ($A_i$) and the next one ($A_{i+1}$).
• beta: Scalar $\beta$. When $\beta = 0$, $C$ need not be set before entry.
• C: Device pointer to the first matrix $C_1$ on the GPU. The imaginary part of the diagonal elements of $C$ is not accessed and is assumed to be 0 unless a quick return is performed.
• ldc: [mublas_int] The leading dimension of $C$. Must be $\text{ldc} \geq \max(1, n)$.
• stride_C: [mublas_stride] The stride from the start of one matrix ($C_i$) and the next one ($C_{i+1}$).
• batch_count: [mublas_int] The number of instances in the batch.

Operation

The herk_strided_batched function performs a batch of matrix-matrix operations for a Hermitian rank-k update:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $\text{op}(A_i)$ is an $n \times k$ matrix.
• $C_i$ is an $n \times n$ Hermitian matrix.
• If $transA = MUBLAS\_OP\_N$, then $\text{op}(A_i) = A_i$.
• If $transA = MUBLAS\_OP\_C$, then $\text{op}(A_i) = A_i^H$.

function 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
)

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t]
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of the Hermitian matrix $A$ is supplied in $AP$.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of the Hermitian matrix $A$ is supplied in $AP$.
• n: [mublas_int] The order of the matrix $A$. Must be $n \geq 0$.
• alpha: Device pointer or host pointer to scalar $\alpha$.
• AP: Device pointer storing the packed version of the specified triangular portion of the Hermitian matrix $A$. It must be of at least size $\frac{n(n + 1)}{2}$. If $uplo = MUBLAS\_FILL\_MODE\_UPPER$, the upper triangular portion of $A$ is supplied. The matrix is packed such that:
  • $AP(0) = A(0,0)$,
  • $AP(1) = A(0,1)$,
  • $AP(2) = A(1,1)$, and so on.
  • If $uplo = MUBLAS\_FILL\_MODE\_LOWER$, the lower triangular portion of $A$ is supplied. The matrix is packed such that:
  • $AP(0) = A(0,0)$,
  • $AP(1) = A(1,0)$,
  • $AP(2) = A(2,1)$, and so on.
  • Note: The imaginary part of the diagonal elements is not accessed and is assumed to be 0.
• x: Device pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• beta: Device pointer or host pointer to scalar $\beta$.
• y: Device pointer storing vector $y$.
• incy: [mublas_int] Specifies the increment for the elements of $y$.

---

Operation

The hpmv function performs the matrix-vector operation:

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

Where:

• $\alpha$ and $\beta$ are scalars.
• $A$ is an $n \times n$ Hermitian matrix supplied in packed form.
• $x$ and $y$ are $n$-element vectors.

function mublasChpr

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

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t] Specifies whether the upper or lower triangular part of $A$ is supplied in $AP$.
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of $A$ is supplied in $AP$.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of $A$ is supplied in $AP$.
• n: [mublas_int] The number of rows and columns of matrix $A$. Must be at least 0.
• alpha: Device or host pointer to scalar $\alpha$.
• x: Device pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• AP: Device pointer storing the packed version of the specified triangular portion of the Hermitian matrix $A$. The size must be at least $((n \times (n + 1)) / 2)$.
  • If $uplo = MUBLAS\_FILL\_MODE\_UPPER$: The upper triangular portion of $A$ is supplied.
  • If $uplo = MUBLAS\_FILL\_MODE\_LOWER$: The lower triangular portion of $A$ is supplied.

Operation

The hpr function performs the matrix-vector operation:

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

Where:

• $\alpha$ is a real scalar.
• $x$ is a vector.
• $A$ is an $n \times n$ Hermitian matrix, supplied in packed form.

function 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
)

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t] Specifies whether the upper or lower triangular part of $A$ is supplied in $AP$.
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of $A$ is supplied in $AP$.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of $A$ is supplied in $AP$.
• n: [mublas_int] The number of rows and columns of matrix $A$. Must be at least 0.
• alpha: Device or host pointer to complex scalar $\alpha$.
• x: Device pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• y: Device pointer storing vector $y$.
• incy: [mublas_int] Specifies the increment for the elements of $y$.
• AP: Device pointer storing the packed version of the specified triangular portion of the Hermitian matrix $A$. The size must be at least $((n \times (n + 1)) / 2)$.
  • If $uplo = MUBLAS\_FILL\_MODE\_UPPER$: The upper triangular portion of $A$ is supplied.
  • If $uplo = MUBLAS\_FILL\_MODE\_LOWER$: The lower triangular portion of $A$ is supplied.

Operation

The hpr2 function performs the matrix-vector operation:

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

Where:

• $\alpha$ is a complex scalar.
• $x$ and $y$ are vectors.
• $A$ is an $n \times n$ Hermitian matrix, supplied in packed form.

function mublasSnrm2

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

function mublasScnrm2

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

function mublasDznrm2

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

function mublasDnrm2

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

BLAS Level 1 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• n: [mublas_int] The number of elements in vector $x$.
• x: Device pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• result: Device or host pointer to store the $nrm2$ result. The return value is $0.0$ if $n \leq 0$ or $incx \leq 0$.

Operation

The nrm2 function computes the Euclidean norm of a real or complex vector:

• For real vectors:

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

• For complex vectors:

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

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• n: [mublas_int] The number of elements in the vectors $x$ and $y$.
• x: Device pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment between elements of $x$.
• y: Device pointer storing vector $y$.
• incy: [mublas_int] Specifies the increment between elements of $y$.
• c: Device or host pointer storing the scalar cosine component ($c = \cos(\alpha)$) of the rotation matrix.
• s: Device or host pointer storing the scalar sine component ($s = \sin(\alpha)$) of the rotation matrix.

Operation

The rot function applies the Givens rotation matrix to vectors $x$ and $y$. The rotation is defined by the cosine and sine components $c$ and $s$, respectively, which are related to an angle $\alpha$:

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

Where:

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

function mublasSrotg

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

function mublasCrotg

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

function mublasDrotg

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

function mublasZrotg

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

BLAS Level 1 API

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• a: Device pointer or host pointer to the input vector element, overwritten with $r$.
• b: Device pointer or host pointer to the input vector element, overwritten with $z$.
• c: Device pointer or host pointer to the cosine element of the Givens rotation.
• s: Device pointer or host pointer to the sine element of the Givens rotation.

Operation

The rotg function creates the Givens rotation matrix for the vector $(a, b)$. The rotation matrix is defined by the cosine and sine components $c$ and $s$, and is applied to the vector:

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

Where:

• $r$ is the new value of $a$ after the rotation.
• $z$ is the new value of $b$ after the rotation.
• $c = \cos(\alpha)$
• $s = \sin(\alpha)$

The result of the rotation is stored in $a$ and $b$ as $r$ and $z$, respectively.

If the pointer mode is set to MUBLAS_POINTER_MODE_HOST, the function blocks the CPU until the GPU finishes and the results are available in host memory. If set to MUBLAS_POINTER_MODE_DEVICE, the function returns immediately, and synchronization is required to read the results.

function mublasSrotm

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

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• n: [mublas_int] The number of elements in the vectors $x$ and $y$.
• x: Device pointer storing vector $x$.
• incx: [mublas_int] Specifies the increment between elements of $x$.
• y: Device pointer storing vector $y$.
• incy: [mublas_int] Specifies the increment between elements of $y$.
• param: Device or host vector of 5 elements defining the rotation:
  • param[0]: flag (Defines the form of matrix $H$).
  • param[1]: $H_{11}$ (Element in the first row, first column).
  • param[2]: $H_{21}$ (Element in the second row, first column).
  • param[3]: $H_{12}$ (Element in the first row, second column).
  • param[4]: $H_{22}$ (Element in the second row, second column).

The flag defines the form of the matrix $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}$

The param vector may be stored in either host or device memory, and the location is specified by calling mublasSetPointerMode.

Operation

The rotm function applies the modified Givens rotation matrix defined by param to the vectors $x$ and $y$. The operation performed is:

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

Where $H$ is one of the four possible matrices defined by the param vector.

function mublasSrotmg

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

function mublasDrotmg

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• d1 device pointer or host pointer to input scalar that is overwritten.
• d2 device pointer or host pointer to input scalar that is overwritten.
• x1 device pointer or host pointer to input scalar that is overwritten.
• y1 device pointer or host pointer to input scalar.
• param device vector or host vector of 5 elements defining the rotation. param[0] = flag param[1] = H11 param[2] = H21 param[3] = H12 param[4] = H22 The flag parameter defines the form of H: flag = -1 => H = ( H11 H12 H21 H22 ) flag = 0 => H = ( 1.0 H12 H21 1.0 ) flag = 1 => H = ( H11 1.0 -1.0 H22 ) flag = -2 => H = ( 1.0 0.0 0.0 1.0 ) param may be stored in either host or device memory, location is specified by calling mublasSetPointerMode.

rotmg creates the modified Givens rotation matrix for the vector (d1 _ x1, d2 _ y1). Parameters may be stored in either host or device memory, location is specified by calling mublasSetPointerMode. If the pointer mode is set to MUBLAS_POINTER_MODE_HOST, this function blocks the CPU until the GPU has finished and the results are available in host memory. If the pointer mode is set to MUBLAS_POINTER_MODE_DEVICE, this function returns immediately and synchronization is required to read the results.

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• d1: Device pointer or host pointer to the input scalar that is overwritten.
• d2: Device pointer or host pointer to the input scalar that is overwritten.
• x1: Device pointer or host pointer to the input scalar that is overwritten.
• y1: Device pointer or host pointer to the input scalar.
• param: Device or host vector of 5 elements defining the rotation:
  • param[0]: flag (Defines the form of matrix $H$).
  • param[1]: $H_{11}$ (Element in the first row, first column).
  • param[2]: $H_{21}$ (Element in the second row, first column).
  • param[3]: $H_{12}$ (Element in the first row, second column).
  • param[4]: $H_{22}$ (Element in the second row, second column).

The flag defines the form of the matrix $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}$

The param vector may be stored in either host or device memory, and the location is specified by calling mublasSetPointerMode.

Operation

The rotmg function creates the modified Givens rotation matrix for the vector $(d1 \cdot x1, d2 \cdot y1)$. Parameters may be stored in either host or device memory, and the location is specified by calling mublasSetPointerMode.

If the pointer mode is set to MUBLAS_POINTER_MODE_HOST, this function blocks the CPU until the GPU has finished and the results are available in host memory.

If the pointer mode is set to MUBLAS_POINTER_MODE_DEVICE, this function returns immediately, and synchronization is required to read the results.

function 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
)

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• uplo: [mublasFillMode_t] Specifies whether the upper (MUBLAS_FILL_MODE_UPPER) or lower (MUBLAS_FILL_MODE_LOWER) part of $A$ is used. If MUBLAS_FILL_MODE_UPPER, the lower part of $A$ is not referenced. If MUBLAS_FILL_MODE_LOWER, the upper part of $A$ is not referenced.
• n: [mublas_int] Specifies the order of the symmetric banded matrix $A$ (number of rows and columns).
• k: [mublas_int] Specifies the number of sub- and super-diagonals in the symmetric banded matrix $A$.
• alpha: [float] Specifies the scalar $\alpha$.
• A: Pointer to the symmetric banded matrix $A$ stored on the GPU.
• lda: [mublas_int] Specifies the leading dimension of the array containing $A$. Must be at least $k + 1$.
• x: Pointer to the vector $x$ stored on the GPU.
• incx: [mublas_int] Specifies the increment for the elements of $x$.
• beta: [float] Specifies the scalar $\beta$.
• y: Pointer to the vector $y$ stored on the GPU.
• incy: [mublas_int] Specifies the increment for the elements of $y$.

Operation

The sbmv function performs the matrix-vector operation:

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

where:

• $\alpha$ and $\beta$ are scalars,
• $x$ and $y$ are $n$-element vectors,
• $A$ is a symmetric banded matrix of order $n$ with $k$ sub- and super-diagonals, stored in a compact form as specified by the lda parameter.

function mublasCscal

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

function mublasZscal

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

function mublasCsscal

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

function mublasSscal

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

function mublasDscal

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

function mublasZscal

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in x.
• alpha device pointer or host pointer for the scalar alpha.
• x device pointer storing vector x.
• incx [mublas_int] specifies the increment for the elements of x.

Operation

scal scales each element of vector $x$ with scalar $\alpha$:

$$x := \alpha \cdot x$$

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo mublasFillMode_t specifies whether the upper 'MUBLAS_FILL_MODE_UPPER' or lower 'MUBLAS_FILL_MODE_LOWER'. If MUBLAS_FILL_MODE_UPPER, the lower part of $A$ is not referenced. If MUBLAS_FILL_MODE_LOWER, the upper part of $A$ is not referenced.
• n [mublas_int] the number of elements in the vectors $x$ and $y$.
• alpha specifies the scalar $\alpha$.
• A pointer storing matrix $A$ on the GPU.
• x pointer storing vector $x$ on the GPU.
• incx [mublas_int] specifies the increment for the elements of $x$.
• beta specifies the scalar $\beta$.
• y pointer storing vector $y$ on the GPU.
• incy [mublas_int] specifies the increment for the elements of $y$.

Operation

The spmv function performs the matrix-vector operation:

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

Where $\alpha$ and $\beta$ are scalars, $x$ and $y$ are $n$-element vectors, and $A$ is a packed symmetric matrix of size $n \times n$ that is either upper or lower triangular.

function mublasSspr

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

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether the upper 'MUBLAS_FILL_MODE_UPPER' or lower 'MUBLAS_FILL_MODE_LOWER':
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of $A$ is supplied in $AP$.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of $A$ is supplied in $AP$.
• n [mublas_int] the number of rows and columns of matrix $A$, must be at least 0.
• alpha device pointer or host pointer to scalar $\alpha$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.
• AP device pointer storing the packed version of the specified triangular portion of the symmetric matrix $A$, of at least size $\frac{n(n+1)}{2}$.
  • If uplo == MUBLAS_FILL_MODE_UPPER, the upper triangular portion of the symmetric matrix $A$ is supplied. The matrix is compacted so that $AP$ contains the triangular portion column-by-column.
  • If uplo == MUBLAS_FILL_MODE_LOWER, the lower triangular portion of the symmetric matrix $A$ is supplied. The matrix is compacted so that $AP$ contains the triangular portion column-by-column.

Operation

The spr function performs the matrix-vector operation:

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

Where $\alpha$ is a scalar, $x$ is a vector, and $A$ is an $n \times n$ symmetric matrix, supplied in packed form.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether the upper 'MUBLAS_FILL_MODE_UPPER' or lower 'MUBLAS_FILL_MODE_LOWER':
  • MUBLAS_FILL_MODE_UPPER: The upper triangular part of $A$ is supplied in $AP$.
  • MUBLAS_FILL_MODE_LOWER: The lower triangular part of $A$ is supplied in $AP$.
• n [mublas_int] the number of rows and columns of matrix $A$, must be at least 0.
• alpha device pointer or host pointer to scalar $\alpha$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.
• y device pointer storing vector $y$.
• incy [mublas_int] specifies the increment for the elements of $y$.
• AP device pointer storing the packed version of the specified triangular portion of the symmetric matrix $A$, of at least size $\frac{n(n+1)}{2}$.
  • If uplo == MUBLAS_FILL_MODE_UPPER, the upper triangular portion of the symmetric matrix $A$ is supplied. The matrix is compacted so that $AP$ contains the triangular portion column-by-column.
  • If uplo == MUBLAS_FILL_MODE_LOWER, the lower triangular portion of the symmetric matrix $A$ is supplied. The matrix is compacted so that $AP$ contains the triangular portion column-by-column.

Operation

The spr2 function performs the matrix-vector operation:

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

Where $\alpha$ is a scalar, $x$ and $y$ are vectors, and $A$ is an $n \times n$ symmetric matrix, supplied in packed form.

function mublasCswap

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in $x$ and $y$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.
• y device pointer storing vector $y$.
• incy [mublas_int] specifies the increment for the elements of $y$.

Operation

The swap function interchanges vectors $x$ and $y$:

$$y := x; \quad x := y$$

function mublasSswap

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

function mublasDswap

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

function mublasZswap

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

BLAS Level 1 API

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• n [mublas_int] the number of elements in $x$ and $y$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.
• y device pointer storing vector $y$.
• incy [mublas_int] specifies the increment for the elements of $y$.

Operation

The swap function interchanges vectors $x$ and $y$:

$$y := x; \quad x := y$$

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• 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$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• m [mublas_int] the number of rows of $B$ and $C$, $m \geq 0$.
• n [mublas_int] the number of columns of $B$ and $C$, $n \geq 0$.
• alpha scalar $\alpha$. When $\alpha$ is zero, $A$ and $B$ are not referenced.
• A pointer storing matrix $A$ on the GPU. $A$ is $m \times m$ if side == MUBLAS_SIDE_LEFT, $A$ is $n \times n$ if side == MUBLAS_SIDE_RIGHT; only the upper/lower triangular part is accessed.
• lda [mublas_int] specifies the first dimension of $A$. If side == MUBLAS_SIDE_LEFT, $\text{lda} \geq \max(1, m)$, otherwise $\text{lda} \geq \max(1, n)$.
• B pointer storing matrix $B$ on the GPU. Matrix dimension is $m \times n$.
• ldb [mublas_int] specifies the first dimension of $B$. $\text{ldb} \geq \max(1, m)$.
• beta scalar $\beta$. When $\beta$ is zero, $C$ need not be set before entry.
• C pointer storing matrix $C$ on the GPU. Matrix dimension is $m \times n$.
• ldc [mublas_int] specifies the first dimension of $C$. $\text{ldc} \geq \max(1, m)$.

Operation

The symm function performs one of the matrix-matrix operations:

• $C := \alpha A B + \beta C$ if side == MUBLAS_SIDE_LEFT
• $C := \alpha B A + \beta C$ if side == MUBLAS_SIDE_RIGHT

where $\alpha$ and $\beta$ are scalars, $B$ and $C$ are $m \times n$ matrices, and $A$ is a symmetric matrix stored as either upper or lower triangular.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• 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$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A_i$ is a lower triangular matrix
• m [mublas_int] specifies the number of rows of $B_i$ and $C_i$, $m \geq 0$.
• n [mublas_int] specifies the number of columns of $B_i$ and $C_i$, $n \geq 0$.
• alpha scalar $\alpha$. When $\alpha$ is zero, $A_i$ and $B_i$ are not referenced.
• A device pointer to the first matrix $A_1$. $A_i$ is $m \times m$ if side == MUBLAS_SIDE_LEFT, $A_i$ is $n \times n$ if side == MUBLAS_SIDE_RIGHT; only the upper/lower triangular part is accessed.
• lda [mublas_int] specifies the first dimension of $A_i$. If side == MUBLAS_SIDE_LEFT, $\text{lda} \geq \max(1, m)$, otherwise $\text{lda} \geq \max(1, n)$.
• stride_A [mublas_stride] stride from the start of one matrix ($A_i$) to the next one ($A_{i+1}$).
• B device pointer to the first matrix $B_1$ of dimension $(\text{ldb}, n)$ on the GPU.
• ldb [mublas_int] specifies the first dimension of $B_i$. $\text{ldb} \geq \max(1, m)$.
• stride_B [mublas_stride] stride from the start of one matrix ($B_i$) to the next one ($B_{i+1}$).
• beta scalar $\beta$. When $\beta$ is zero, $C$ need not be set before entry.
• C device pointer to the first matrix $C_1$ of dimension $(\text{ldc}, n)$ on the GPU.
• ldc [mublas_int] specifies the first dimension of $C$. $\text{ldc} \geq \max(1, m)$.
• stride_C [mublas_stride] stride from the start of one matrix ($C_i$) to the next one ($C_{i+1}$).
• batch_count [mublas_int] the number of instances in the batch.

Operation

The symm_strided_batched function performs a batch of the matrix-matrix operations:

• $C_i := \alpha A_i B_i + \beta C_i$ if side == MUBLAS_SIDE_LEFT
• $C_i := \alpha B_i A_i + \beta C_i$ if side == MUBLAS_SIDE_RIGHT

where $\alpha$ and $\beta$ are scalars, $B_i$ and $C_i$ are $m \times n$ matrices, and $A_i$ is a symmetric matrix stored as either upper or lower triangular.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether the upper or lower part of $A$ is referenced:
  • MUBLAS_FILL_MODE_UPPER: the lower part of $A$ is not referenced
  • MUBLAS_FILL_MODE_LOWER: the upper part of $A$ is not referenced
• n [mublas_int] the number of elements in vector $x$ and $y$.
• alpha scalar $\alpha$.
• A pointer storing matrix $A$ on the GPU. $A$ is an $n \times n$ symmetric matrix, stored either as upper or lower triangular.
• lda [mublas_int] specifies the leading dimension of $A$.
• x pointer storing vector $x$ on the GPU.
• incx [mublas_int] specifies the increment for the elements of $x$.
• beta scalar $\beta$.
• y pointer storing vector $y$ on the GPU.
• incy [mublas_int] specifies the increment for the elements of $y$.

Operation

The symv function performs the matrix-vector operation:

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

where $\alpha$ and $\beta$ are scalars, $x$ and $y$ are $n$-element vectors, and $A$ is a symmetric $n \times n$ matrix, stored in either upper or lower triangular form.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether the upper or lower part of $A$ is referenced:
  • MUBLAS_FILL_MODE_UPPER: the lower part of $A$ is not referenced
  • MUBLAS_FILL_MODE_LOWER: the upper part of $A$ is not referenced
• n [mublas_int] the number of rows and columns of matrix $A$.
• alpha device pointer or host pointer to scalar $\alpha$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.
• A device pointer storing matrix $A$.
• lda [mublas_int] specifies the leading dimension of $A$.

Operation

The syr function performs the matrix-vector operation:

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

where $\alpha$ is a scalar, $x$ is a vector, and $A$ is an $n \times n$ symmetric matrix.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether the upper or lower part of $A$ is referenced:
  • MUBLAS_FILL_MODE_UPPER: the lower part of $A$ is not referenced
  • MUBLAS_FILL_MODE_LOWER: the upper part of $A$ is not referenced
• n [mublas_int] the number of rows and columns of matrix $A$.
• alpha device pointer or host pointer to scalar $\alpha$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.
• y device pointer storing vector $y$.
• incy [mublas_int] specifies the increment for the elements of $y$.
• A device pointer storing matrix $A$.
• lda [mublas_int] specifies the leading dimension of $A$.

Operation

The syr2 function performs the matrix-vector operation:

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

where $\alpha$ is a scalar, $x$ and $y$ are vectors, and $A$ is an $n \times n$ symmetric matrix.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $C$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $C$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $C$ is a lower triangular matrix
• trans [mublasOperation_t] specifies the operation on matrices $A$ and $B$:
  • MUBLAS_OP_T: $op(A) = A^T$, $op(B) = B^T$
  • MUBLAS_OP_N: $op(A) = A$, $op(B) = B$
• n [mublas_int] specifies the number of rows and columns of $C$. $n \geq 0$.
• k [mublas_int] specifies the number of columns of $op(A)$ and $op(B)$. $k \geq 0$.
• alpha specifies the scalar $\alpha$. When $\alpha$ is zero, $A$ and $B$ are not referenced.
• A pointer to matrix $A$ on the GPU. Matrix dimension is $(\text{lda}, k)$ if $trans = MUBLAS_OP_N$, otherwise $(\text{lda}, n)$. Only the upper/lower triangular part of $A$ is accessed.
• lda [mublas_int] specifies the first dimension of $A$. If $trans = MUBLAS_OP_N$, $\text{lda} \geq \max(1, n)$, otherwise $\text{lda} \geq \max(1, k)$.
• B pointer to matrix $B$ on the GPU. Matrix dimension is $(\text{ldb}, k)$ if $trans = MUBLAS_OP_N$, otherwise $(\text{ldb}, n)$. Only the upper/lower triangular part of $B$ is accessed.
• ldb [mublas_int] specifies the first dimension of $B$. If $trans = MUBLAS_OP_N$, $\text{ldb} \geq \max(1, n)$, otherwise $\text{ldb} \geq \max(1, k)$.
• beta specifies the scalar $\beta$. When $\beta$ is zero, $C$ need not be set before entry.
• C pointer to matrix $C$ on the GPU.
• ldc [mublas_int] specifies the first dimension of $C$. $\text{ldc} \geq \max(1, n)$.

Operation

The syr2k function performs the symmetric rank-2k update:

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

where $\alpha$ and $\beta$ are scalars, $op(A)$ and $op(B)$ are $n \times k$ matrices, and $C$ is an $n \times n$ symmetric matrix stored as either upper or lower triangular.

The operation can be either:

• $op(A) = A$, $op(B) = B$ when $trans = \text{MUBLAS\_OP\_N}$
• $op(A) = A^T$, $op(B) = B^T$ when trans = \text{MUBLAS_OP_T}

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $C$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $C$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $C$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the operation on matrix $A$:
  • MUBLAS_OP_T: $op(A) = A^T$
  • MUBLAS_OP_N: $op(A) = A$
  • MUBLAS_OP_C: $op(A) = A^T$
• n [mublas_int] specifies the number of rows and columns of $C$. $n \geq 0$.
• k [mublas_int] specifies the number of columns of $op(A)$. $k \geq 0$.
• alpha specifies the scalar $\alpha$. When $\alpha$ is zero, $A$ is not referenced and need not be set before entry.
• A pointer to matrix $A$ on the GPU. Matrix dimension is $(\text{lda}, k)$ if $transA = MUBLAS_OP_N$, otherwise $(\text{lda}, n)$. Only the upper/lower triangular part of $A$ is accessed.
• lda [mublas_int] specifies the first dimension of $A$. If $transA = MUBLAS_OP_N$, $\text{lda} \geq \max(1, n)$, otherwise $\text{lda} \geq \max(1, k)$.
• beta specifies the scalar $\beta$. When $\beta$ is zero, $C$ need not be set before entry.
• C pointer to matrix $C$ on the GPU.
• ldc [mublas_int] specifies the first dimension of $C$. $\text{ldc} \geq \max(1, n)$.

Operation

The syrk function performs the symmetric rank-k update:

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

where $\alpha$ and $\beta$ are scalars, $op(A)$ is an $n \times k$ matrix, and $C$ is a symmetric $n \times n$ matrix stored as either upper or lower triangular.

The operation can be either:

• $op(A) = A$, and $A$ is $n \times k$ if transA = \text{MUBLAS_OP_N}
• $op(A) = A^T$, and $A$ is $k \times n$ if transA = \text{MUBLAS_OP_T}

Note: MUBLAS_OP_C is not supported for complex types. See cherk and zherk.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $C_i$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $C_i$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $C_i$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the operation on matrix $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] specifies the number of rows and columns of $C_i$. $n \geq 0$.
• k [mublas_int] specifies the number of columns of $op(A_i)$. $k \geq 0$.
• alpha specifies the scalar $\alpha$. When $\alpha$ is zero, $A_i$ is not referenced and need not be set before entry.
• A pointer to the first matrix $A_1$ on the GPU. The matrix dimension is $(\text{lda}, k)$ if $transA = MUBLAS_OP_N$, otherwise $(\text{lda}, n)$.
• lda [mublas_int] specifies the first dimension of $A_i$. If $transA = MUBLAS_OP_N$, $\text{lda} \geq \max(1, n)$, otherwise $\text{lda} \geq \max(1, k)$.
• stride_A [mublas_stride] stride from the start of one matrix ($A_i$) and the next one ($A_{i+1}$).
• beta specifies the scalar $\beta$. When $\beta$ is zero, $C_i$ need not be set before entry.
• C pointer to the first matrix $C_1$ on the GPU.
• ldc [mublas_int] specifies the first dimension of $C$. $\text{ldc} \geq \max(1, n)$.
• stride_C [mublas_stride] stride from the start of one matrix ($C_i$) and the next one ($C_{i+1}$).
• batch_count [mublas_int] number of instances in the batch.

Operation

The syrk_strided_batched function performs a batch of the matrix-matrix operations for a symmetric rank-k update:

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

where $\alpha$ and $\beta$ are scalars, $op(A_i)$ is an $n \times k$ matrix, and $C_i$ is a symmetric $n \times n$ matrix stored as either upper or lower triangular.

The operation can be either:

• $op(A_i) = A_i$, and $A_i$ is $n \times k$ if transA = \text{MUBLAS_OP_N}
• $op(A_i) = A_i^T$, and $A_i$ is $k \times n$ if transA = \text{MUBLAS_OP_T}

Note: MUBLAS_OP_C is not supported for complex types. See cherk and zherk.

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $C$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $C$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $C$ is a lower triangular matrix
• trans [mublasOperation_t] specifies the operation on matrices $A$ and $B$:
  • MUBLAS_OP_T: $op(A) = A^T$, $op(B) = B^T$
  • MUBLAS_OP_N: $op(A) = A$, $op(B) = B$
• n [mublas_int] specifies the number of rows and columns of $C$. $n \geq 0$.
• k [mublas_int] specifies the number of columns of $op(A)$ and $op(B)$. $k \geq 0$.
• alpha specifies the scalar $\alpha$. When $\alpha$ is zero, $A$ is not referenced and need not be set before entry.
• A pointer to matrix $A$ on the GPU. Matrix dimension is $(\text{lda}, k)$ if $trans = MUBLAS_OP_N$, otherwise $(\text{lda}, n)$.
• lda [mublas_int] specifies the first dimension of $A$. If $trans = MUBLAS_OP_N$, $\text{lda} \geq \max(1, n)$, otherwise $\text{lda} \geq \max(1, k)$.
• B pointer to matrix $B$ on the GPU. Matrix dimension is $(\text{ldb}, k)$ if $trans = MUBLAS_OP_N$, otherwise $(\text{ldb}, n)$.
• ldb [mublas_int] specifies the first dimension of $B$. If $trans = MUBLAS_OP_N$, $\text{ldb} \geq \max(1, n)$, otherwise $\text{ldb} \geq \max(1, k)$.
• beta specifies the scalar $\beta$. When $\beta$ is zero, $C$ need not be set before entry.
• C pointer to matrix $C$ on the GPU.
• ldc [mublas_int] specifies the first dimension of $C$. $\text{ldc} \geq \max(1, n)$.

Operation

The syrkx function performs a matrix-matrix operation for a symmetric rank-k update:

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

where $\alpha$ and $\beta$ are scalars, $op(A)$ and $op(B)$ are $n \times k$ matrices, and $C$ is a symmetric $n \times n$ matrix stored as either upper or lower triangular.

The operation can be either:

• $op(A) = A$, $op(B) = B$, and $A$ and $B$ are $n \times k$ if $trans = \text{MUBLAS\_OP\_N}$
• $op(A) = A^T$, $op(B) = B^T$, and $A$ and $B$ are $k \times n$ if $trans = MUBLAS\_OP\_T$

This routine should only be used when the result of $op(A) \cdot op(B)^T$ is guaranteed to be symmetric.

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $C_i$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $C_i$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $C_i$ is a lower triangular matrix
• trans [mublasOperation_t] specifies the operation on matrices $A_i$ and $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] specifies the number of rows and columns of $C_i$. $n \geq 0$.
• k [mublas_int] specifies the number of columns of $op(A_i)$. $k \geq 0$.
• alpha specifies the scalar $\alpha$. When $\alpha$ is zero, $A_i$ is not referenced and need not be set before entry.
• A pointer to matrix $A_1$ on the GPU. Matrix dimension is $(\text{lda}, k)$ if $trans = \text{MUBLAS\_OP\_N}$, otherwise $(\text{lda}, n)$.
• lda [mublas_int] specifies the first dimension of $A_i$. If $trans = \text{MUBLAS\_OP\_N}$, $\text{lda} \geq \max(1, n)$, otherwise $\text{lda} \geq \max(1, k)$.
• stride_A [mublas_stride] specifies the stride from the start of one matrix ($A_i$) to the next one ($A_{i+1}$).
• B pointer to matrix $B_1$ on the GPU. Matrix dimension is $(\text{ldb}, k)$ if $trans = \text{MUBLAS\_OP\_N}$, otherwise $(\text{ldb}, n)$.
• ldb [mublas_int] specifies the first dimension of $B_i$. If $trans = \text{MUBLAS\_OP\_N}$, $\text{ldb} \geq \max(1, n)$, otherwise $\text{ldb} \geq \max(1, k)$.
• stride_B [mublas_stride] specifies the stride from the start of one matrix ($B_i$) to the next one ($B_{i+1}$).
• beta specifies the scalar $\beta$. When $\beta$ is zero, $C_i$ need not be set before entry.
• C pointer to matrix $C_1$ on the GPU.
• ldc [mublas_int] specifies the first dimension of $C$. $\text{ldc} \geq \max(1, n)$.
• stride_C [mublas_stride] specifies the stride from the start of one matrix ($C_i$) to the next one ($C_{i+1}$).
• batch_count [mublas_int] specifies the number of instances in the batch.

Operation

The syrkx_strided_batched function performs a batch of matrix-matrix operations for a symmetric rank-k update:

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

where $\alpha$ and $\beta$ are scalars, $op(A_i)$ and $op(B_i)$ are $n \times k$ matrices, and $C_i$ is a symmetric $n \times n$ matrix stored as either upper or lower triangular.

The operation can be either:

• $op(A_i) = A_i$, $op(B_i) = B_i$, and $A_i$, $B_i$ are $n \times k$ if $trans = \text{MUBLAS\_OP\_N}$
• $op(A_i) = A_i^T$, $op(B_i) = B_i^T$, and $A_i$, $B_i$ are $k \times n$ if $trans = \text{MUBLAS\_OP\_T}$

This routine should only be used when the result of $op(A_i) \cdot op(B_i)^T$ is guaranteed to be symmetric.

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $A$ is stored as upper or lower banded triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper banded triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower banded triangular matrix
• trans [mublasOperation_t] specifies the operation on matrix $A$:
  • MUBLAS_OP_T: $op(A) = A^T$
  • MUBLAS_OP_N: $op(A) = A$
• diag [mublasDiagType_t] specifies the type of diagonal of $A$:
  • MUBLAS_DIAG_UNIT: The main diagonal of $A$ is assumed to consist of only 1's and is not referenced
  • MUBLAS_DIAG_NON_UNIT: No assumptions are made about $A$'s main diagonal
• m [mublas_int] specifies the number of rows and columns of the matrix represented by $A$.
• k [mublas_int] specifies the number of diagonals of $A$:
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$, $k$ specifies the number of super-diagonals.
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$, $k$ specifies the number of sub-diagonals.
  • $k$ must satisfy $k > 0$ and $k < \text{lda}$
• A device pointer storing the banded triangular matrix $A$.
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$, $A$ represents an upper banded triangular matrix with the main diagonal and $k$ super-diagonals.
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$, $A$ represents a lower banded triangular matrix with the main diagonal and $k$ sub-diagonals.
• lda [mublas_int] specifies the leading dimension of $A$. Must satisfy $\text{lda} > k$.
• x device pointer storing the vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.

Operation

The tbmv function performs one of the following matrix-vector operations:

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

where $x$ is a vector and $A$ is a banded $m \times m$ matrix.

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $A$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the operation on matrix $A$:
  • MUBLAS_OP_N: Solves $A \cdot x = b$
  • MUBLAS_OP_T: Solves $A^T \cdot x = b$
  • MUBLAS_OP_C: Solves $A^H \cdot x = b$
• diag [mublasDiagType_t] specifies the type of diagonal of $A$:
  • MUBLAS_DIAG_UNIT: $A$ is assumed to be unit triangular (i.e., the diagonal elements of $A$ are not used in computations)
  • MUBLAS_DIAG_NON_UNIT: $A$ is not assumed to be unit triangular
• n [mublas_int] specifies the number of rows of $b$. $n \geq 0$.
• k [mublas_int] specifies the number of diagonals of $A$:
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$, $k$ specifies the number of super-diagonals of $A$.
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$, $k$ specifies the number of sub-diagonals of $A$.
  • $k \geq 0$
• A device pointer storing the matrix $A$ in banded format.
• lda [mublas_int] specifies the leading dimension of $A$. $\text{lda} \geq (k + 1)$.
• x device pointer storing input vector $b$. Overwritten by the output vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.

Operation

The tbsv function solves the following systems of equations:

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

where $x$ and $b$ are vectors, and $A$ is a banded triangular matrix.

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $A$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the operation on matrix $A$:
  • MUBLAS_OP_N: Solves $A \cdot x$
  • MUBLAS_OP_T: Solves $A^T \cdot x$
• diag [mublasDiagType_t] specifies the type of diagonal of $A$:
  • MUBLAS_DIAG_UNIT: $A$ is assumed to be unit triangular (i.e., the diagonal elements of $A$ are not used in computations)
  • MUBLAS_DIAG_NON_UNIT: $A$ is not assumed to be unit triangular
• m [mublas_int] specifies the number of rows of $A$. $m \geq 0$.
• A device pointer storing the matrix $A$. The matrix is stored in packed form:
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_UPPER}$, the array $A$ contains the upper triangular matrix packed sequentially, column by column.
  • If $uplo = \text{MUBLAS\_FILL\_MODE\_LOWER}$, the array $A$ contains the lower triangular matrix packed sequentially, column by column.
  • When $diag = \text{MUBLAS\_DIAG\_UNIT}$, the diagonal elements of $A$ are not referenced, but are assumed to be unity.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$. $\text{incx}$ must not be zero.

Operation

The tpmv function performs the following matrix-vector operation:

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

where $x$ is an $n$-element vector, and $A$ is an $n \times n$ unit or non-unit upper or lower triangular matrix, supplied in packed form.

The vector $x$ is overwritten.

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $A$ is stored as upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the operation on matrix $A$:
  • MUBLAS_OP_N: Solves $A \cdot x = b$
  • MUBLAS_OP_T: Solves $A^T \cdot x = b$
  • MUBLAS_OP_C: Solves $A^H \cdot x = b$
• diag [mublasDiagType_t] specifies the type of diagonal of $A$:
  • MUBLAS_DIAG_UNIT: $A$ is assumed to be unit triangular (i.e., the diagonal elements of $A$ are not used in computations)
  • MUBLAS_DIAG_NON_UNIT: $A$ is not assumed to be unit triangular
• n [mublas_int] specifies the number of rows of $b$. $n \geq 0$.
• AP device pointer storing the packed version of matrix $A$, with dimension $\geq \frac{n \cdot (n + 1)}{2}$.
• x device pointer storing vector $b$ on input, overwritten by $x$ on output.
• incx [mublas_int] specifies the increment for the elements of $x$.

Operation

The tpsv function performs the following matrix-vector operation:

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

where $x$ and $b$ are vectors, and $A$ is a triangular matrix stored in packed format.

The input vector $b$ is overwritten by the output vector $x$.

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• side [mublasSideMode_t] specifies whether op($A$) multiplies $B$ from the left or right:
  • 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] specifies whether matrix $A$ is upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the form of $\text{op}(A)$ to be used in the matrix multiplication:
  • 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] specifies whether or not $A$ is unit triangular:
  • MUBLAS_DIAG_UNIT: $A$ is assumed to be unit triangular
  • MUBLAS_DIAG_NON_UNIT: $A$ is not assumed to be unit triangular
• m [mublas_int] specifies the number of rows of $B$. $m \geq 0$.
• n [mublas_int] specifies the number of columns of $B$. $n \geq 0$.
• alpha specifies the scalar $\alpha$. When $\alpha = 0$, $A$ is not referenced, and $B$ need not be set before entry.
• A device pointer to matrix $A$ on the GPU. $A$ has dimension $(\text{lda}, k)$, where $k$ is $m$ when $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ and $k$ is $n$ when $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$.
• lda [mublas_int] specifies the first dimension of $A$. If $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$, $\text{lda} \geq \max( 1, m )$, if $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$, $\text{lda} \geq \max( 1, n )$.
• B device pointer to the first matrix $B_0$ on the GPU. On entry, the leading $m \times n$ part of the array $B$ must contain the matrix $B$, and on exit, it is overwritten by the transformed matrix.
• ldb [mublas_int] specifies the first dimension of $B$. $\text{ldb} \geq \max( 1, m )$.

Operation

The trmm function performs one of the matrix-matrix operations:

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

where $\alpha$ is a scalar, $B$ is an $m \times n$ matrix, $A$ is a unit or non-unit upper or lower triangular matrix, and $\text{op}( A )$ is one of:

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

• When $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_UPPER}$, the leading $k \times k$ upper triangular part of the array $A$ must contain the upper triangular matrix, and the strictly lower triangular part of $A$ is not referenced. Here, $k$ is $m$ when $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ and $k$ is $n$ when $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$.
• When $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_LOWER}$, the leading $k \times k$ lower triangular part of the array $A$ must contain the lower triangular matrix, and the strictly upper triangular part of $A$ is not referenced. Here, $k$ is $m$ when $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ and $k$ is $n$ when $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$.

Note that when $\text{diag} = \text{MUBLAS\_DIAG\_UNIT}$, the diagonal elements of $A$ are not referenced and are assumed to be unity.

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• side [mublasSideMode_t] specifies whether op($A_i$) multiplies $B_i$ from the left or right:
  • 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] specifies whether matrix $A$ is upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the form of $\text{op}(A_i)$ to be used in the matrix multiplication:
  • 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] specifies whether or not $A_i$ is unit triangular:
  • MUBLAS_DIAG_UNIT: $A_i$ is assumed to be unit triangular
  • MUBLAS_DIAG_NON_UNIT: $A_i$ is not assumed to be unit triangular
• m [mublas_int] specifies the number of rows of $B_i$. $m \geq 0$.
• n [mublas_int] specifies the number of columns of $B_i$. $n \geq 0$.
• alpha specifies the scalar $\alpha$. When $\alpha = 0$, $A_i$ is not referenced, and $B_i$ need not be set before entry.
• A device pointer to the first matrix $A_0$ on the GPU. Each $A_i$ is of dimension $(\text{lda}, k)$, where $k$ is $m$ when $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$ and $k$ is $n$ when $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$.
• lda [mublas_int] specifies the first dimension of $A$. If $\text{side} = \text{MUBLAS\_SIDE\_LEFT}$, $\text{lda} \geq \max( 1, m )$, if $\text{side} = \text{MUBLAS\_SIDE\_RIGHT}$, $\text{lda} \geq \max( 1, n )$.
• stride_A [mublas_stride] stride from the start of one matrix ($A_i$) to the next one ($A_{i+1}$).
• B device pointer to the first matrix $B_0$ on the GPU. On entry, the leading $m \times n$ part of the array $B_i$ must contain the matrix $B_i$, and on exit, it is overwritten by the transformed matrix.
• ldb [mublas_int] specifies the first dimension of $B_i$. $\text{ldb} \geq \max( 1, m )$.
• stride_B [mublas_stride] stride from the start of one matrix ($B_i$) to the next one ($B_{i+1}$).
• batch_count [mublas_int] specifies the number of instances $i$ in the batch.

Operation

The trmm_strided_batched function performs one of the strided-batched matrix-matrix operations:

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

where $\alpha$ is a scalar, $B_i$ is an $m \times n$ matrix, $A_i$ is a unit or non-unit upper or lower triangular matrix, and $\text{op}( A_i )$ is one of:

$\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$

• When $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_UPPER}$, the leading $k \times k$ upper triangular part of the array $A$ must contain the upper triangular matrix, and the strictly lower triangular part of $A$ is not referenced.
• When $\text{uplo} = \text{MUBLAS\_FILL\_MODE\_LOWER}$, the leading $k \times k$ lower triangular part of the array $A$ must contain the lower triangular matrix, and the strictly upper triangular part of $A$ is not referenced.

Note that when $\text{diag} = \text{MUBLAS\_DIAG\_UNIT}$, the diagonal elements of $A_i$ are not referenced and are assumed to be unity.

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $A$ is upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the form of $\text{op}(A)$ to be used in the matrix-vector operation:
  • 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] specifies whether or not $A$ is unit triangular:
  • MUBLAS_DIAG_UNIT: $A$ is assumed to be unit triangular
  • MUBLAS_DIAG_NON_UNIT: $A$ is not assumed to be unit triangular
• m [mublas_int] specifies the number of rows of $A$. $m \geq 0$.
• A device pointer storing matrix $A$, of dimension $(\text{lda}, m)$.
• lda [mublas_int] specifies the leading dimension of $A$. $\text{lda} = \max( 1, m )$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.

trmv performs one of the matrix-vector operations:

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

where $x$ is an $n$-element vector and $A$ is an $n \times n$ unit, or non-unit, upper or lower triangular matrix.

The vector $x$ is overwritten.

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• 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$ is an upper triangular matrix. MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix.
• 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$ is assumed to be unit triangular. MUBLAS_DIAG_NON_UNIT: $A$ is not assumed to be unit triangular.
• m [mublas_int] $m$ specifies the number of rows of $B$. $m \geq 0$.
• n [mublas_int] $n$ specifies the number of columns of $B$. $n \geq 0$.
• alpha device pointer or host pointer specifying the scalar $\alpha$. When $\alpha$ is zero then $A$ is not referenced and $B$ need not be set before entry.
• A device pointer storing matrix $A$, of dimension ($\text{lda}$, $k$), where $k$ is $m$ when MUBLAS_SIDE_LEFT and is $n$ when MUBLAS_SIDE_RIGHT. Only the upper/lower triangular part is accessed.
• lda [mublas_int] $\text{lda}$ specifies the first dimension of $A$. If side = MUBLAS_SIDE_LEFT, $\text{lda} \geq \max( 1, m )$, if side = MUBLAS_SIDE_RIGHT, $\text{lda} \geq \max( 1, n )$.
• B device pointer storing matrix $B$.
• ldb [mublas_int] $\text{ldb}$ specifies the first dimension of $B$. $\text{ldb} \geq \max( 1, m )$.

trsm solves one of the following matrix equations:

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

where $\alpha$ is a scalar, $X$ and $B$ are $m \times n$ matrices, $A$ is a triangular matrix and $op(A)$ is one of:

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

The matrix $X$ is overwritten on $B$.

Note about memory allocation: When trsm is launched with a $k$ evenly divisible by the internal block size of 128, and is no larger than 10 of these blocks, the API takes advantage of utilizing pre-allocated memory found in the handle to increase overall performance. This memory can be managed by using the environment variable WORKBUF_TRSM_B_CHNK. When this variable is not set, the device memory used for temporary storage will default to 1 MB and may result in chunking, which in turn may reduce performance. Under these circumstances, it is recommended that WORKBUF_TRSM_B_CHNK be set to the desired chunk of right-hand sides to be used at a time.

(where $k$ is $m$ when MUBLAS_SIDE_LEFT and is $n$ when MUBLAS_SIDE_RIGHT)

function 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
)

function 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
)

function 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
)

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• uplo [mublasFillMode_t] specifies whether matrix $A$ is upper or lower triangular:
  • MUBLAS_FILL_MODE_UPPER: $A$ is an upper triangular matrix
  • MUBLAS_FILL_MODE_LOWER: $A$ is a lower triangular matrix
• transA [mublasOperation_t] specifies the form of $\text{op}(A)$ to be used in the matrix-vector operation:
  • 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] specifies whether or not $A$ is unit triangular:
  • MUBLAS_DIAG_UNIT: $A$ is assumed to be unit triangular
  • MUBLAS_DIAG_NON_UNIT: $A$ is not assumed to be unit triangular
• m [mublas_int] specifies the number of rows of $b$. $m \geq 0$.
• A device pointer storing matrix $A$, of dimension $(\text{lda}, m)$.
• lda [mublas_int] specifies the leading dimension of $A$. $\text{lda} = \max( 1, m )$.
• x device pointer storing vector $x$.
• incx [mublas_int] specifies the increment for the elements of $x$.

trsv solves:

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

where $x$ and $b$ are vectors and $A$ is a triangular matrix.

The vector $x$ is overwritten on $b$.

function 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

Parameters:

• handle [mublasHandle_t] handle to the mublas library context queue.
• trans [mublasOperation_t] indicates whether matrices $A_i$ are transposed (conjugated) or not.
• m [mublas_int] number of rows of each matrix $A_i$.
• n [mublas_int] number of columns of each matrix $A_i$.
• alpha device pointer or host pointer to scalar $\alpha$.
• A device array of device pointers storing each matrix $A_i$.
• lda [mublas_int] specifies the leading dimension of each matrix $A_i$.
• x device array of device pointers storing each vector $x_i$.
• incx [mublas_int] specifies the increment for the elements of each vector $x_i$.
• beta device pointer or host pointer to scalar $\beta$.
• y device array of device pointers storing each vector $y_i$.
• incy [mublas_int] specifies the increment for the elements of each vector $y_i$.
• batch_count [mublas_int] number of instances in the batch.

gemv_batched performs a batch of matrix-vector operations:

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

where $(A_i, x_i, y_i)$ is the $i$-th instance of the batch. $\alpha$ and $\beta$ are scalars, $x_i$ and $y_i$ are vectors, and $A_i$ is an $m \times n$ matrix, for $i = 1, \dots, \text{batch\_count}$.

function mublasGetMathMode

mublasStatus mublasGetMathMode(
    mublasHandle_t handle,
    mublasMathMode_t * math_mode
)

Retrieves the current math mode.

function mublasSetMathMode

mublasStatus mublasSetMathMode(
    mublasHandle_t handle,
    mublasMathMode_t math_mode
)

Sets the math mode.

function mublasGetVersion

mublasStatus mublasGetVersion(
    mublasHandle_t handle,
    int * version
)

Retrieves the version number of the muBLAS library.

function mublasCreate

mublasStatus mublasCreate(
    mublasHandle_t * handle
)

create handle

function mublasDestroy

mublasStatus mublasDestroy(
    mublasHandle_t handle
)

destroy handle

function mublasSetStream

mublasStatus mublasSetStream(
    mublasHandle_t handle,
    MUstream stream
)

set stream for handle

function mublasGetPointerMode

mublasStatus mublasGetPointerMode(
    mublasHandle_t handle,
    mublasPointerMode_t * pointer_mode
)

get mublasPointerMode_t

function mublasSetPointerMode

mublasStatus mublasSetPointerMode(
    mublasHandle_t handle,
    mublasPointerMode_t pointer_mode
)

set mublasPointerMode_t

function 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
)

asynchronously copy matrix from device to host

Parameters

• rows [mublas_int]
  Number of rows in the matrices.

• cols [mublas_int]
  Number of columns in the matrices.

• elem_size [mublas_int]
  Number of bytes per element in the matrix.

• a
  Pointer to the matrix on the GPU.

• lda [mublas_int]
  Specifies the leading dimension of $A$, where $\text{lda} \geq \text{rows}$.

• b
  Pointer to the matrix on the host.

• ldb [mublas_int]
  Specifies the leading dimension of $B$, where $\text{ldb} \geq \text{rows}$.

• stream
  Specifies the stream into which this transfer request is queued.

mublasGetMatrixAsync copies a matrix from device memory to pinned host memory asynchronously.

• Host memory must be allocated with hipHostMalloc.
• If the host memory is not pinned, the transfer will occur synchronously.

function mublasGetError

mublasStatus mublasGetError(
    void
)

This function is deprecated.

function mublasGetMatrix

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

copy matrix from device to host

Parameters

• rows [mublas_int]
  Number of rows in the matrices.

• cols [mublas_int]
  Number of columns in the matrices.

• elem_size [mublas_int]
  Number of bytes per element in the matrix.

• a
  Pointer to the matrix on the GPU.

• lda [mublas_int]
  Specifies the leading dimension of $A$, where $\text{lda} \geq \text{rows}$.

• b
  Pointer to the matrix on the host.

• ldb [mublas_int]
  Specifies the leading dimension of $B$, where $\text{ldb} \geq \text{rows}$.

function mublasShutdown

mublasStatus mublasShutdown(
    void
)

This function is deprecated.

function mublasGetVector

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

copy vector from device to host

Parameters

• n [mublas_int]
  Number of elements in the vector.

• elem_size [mublas_int]
  Number of bytes per element in the vector.

• x
  Pointer to the vector on the device.

• incx [mublas_int]
  Specifies the increment for the elements of the vector $x$.

• y
  Pointer to the vector on the host.

• incy [mublas_int]
  Specifies the increment for the elements of the vector $y$.

function mublasGetLoggerCallback

mublasStatus mublasGetLoggerCallback(
    mublasLogCallback * userCallback
)

This function retrieves function pointer to previously installed custom user defined callback function via mublasSetLoggerCallback() or zero otherwise.

Parameters:

• userCallback Pointer to user defined callback function.

function mublasGetProperty

mublasStatus mublasGetProperty(
    libraryPropertyType_t type,
    int * value
)

get the value of the requested property

function 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
)

asynchronously copy matrix from host to device

Parameters:

• rows [mublas_int] number of rows in matrices
• cols [mublas_int] number of columns in matrices
• elem_size [mublas_int] number of bytes per element in the matrix
• a pointer to matrix on the host
• lda [mublas_int] specifies the leading dimension of A, lda >= rows
• b pointer to matrix on the GPU
• ldb [mublas_int] specifies the leading dimension of B, ldb >= rows
• stream specifies the stream into which this transfer request is queued

mublasSetMatrixAsync copies a matrix from pinned host memory to device memory asynchronously. Memory on the host must be allocated with hipHostMalloc or the transfer will be synchronous.

function mublasSetMatrix

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

copy matrix from host to device

Parameters:

• rows [mublas_int] number of rows in matrices
• cols [mublas_int] number of columns in matrices
• elem_size [mublas_int] number of bytes per element in the matrix
• a pointer to matrix on the host
• lda [mublas_int] specifies the leading dimension of A, lda >= rows
• b pointer to matrix on the GPU
• ldb [mublas_int] specifies the leading dimension of B, ldb >= rows

function mublasGetVectorAsync

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

asynchronously copy vector from device to host

Parameters:

• n [mublas_int] number of elements in the vector
• elem_size [mublas_int] number of bytes per element in the matrix
• x pointer to vector on the device
• incx [mublas_int] specifies the increment for the elements of the vector
• y pointer to vector on the host
• incy [mublas_int] specifies the increment for the elements of the vector
• stream specifies the stream into which this transfer request is queued

mublasGetVectorAsync copies a vector from pinned host memory to device memory asynchronously. Memory on the host must be allocated with hipHostMalloc or the transfer will be synchronous.

mublasFree

mublasSetAtomicsMode

mublasSetVectorAsync

mublasGetAtomicsMode

mublasGetmudartVersion

mublasSetVector

mublasInit

mublasAlloc

mublasSetKernelStream

mublasSetLoggerCallback

mublasLoggerConfigure

function 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
)

asynchronously copy matrix from host to device

Parameters:

• rows [mublas_int] number of rows in matrices
• cols [mublas_int] number of columns in matrices
• elem_size [mublas_int] number of bytes per element in the matrix
• a pointer to matrix on the host
• lda [mublas_int] specifies the leading dimension of A, lda >= rows
• b pointer to matrix on the GPU
• ldb [mublas_int] specifies the leading dimension of B, ldb >= rows
• stream specifies the stream into which this transfer request is queued

mublasSetMatrixAsync copies a matrix from pinned host memory to device memory asynchronously. Memory on the host must be allocated with hipHostMalloc or the transfer will be synchronous.

function mublasSetMatrix

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

copy matrix from host to device

Parameters:

• rows [mublas_int] number of rows in matrices
• cols [mublas_int] number of columns in matrices
• elem_size [mublas_int] number of bytes per element in the matrix
• a pointer to matrix on the host
• lda [mublas_int] specifies the leading dimension of A, lda >= rows
• b pointer to matrix on the GPU
• ldb [mublas_int] specifies the leading dimension of B, ldb >= rows

function mublasGetVectorAsync

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

asynchronously copy vector from device to host

Parameters:

• n [mublas_int] number of elements in the vector
• elem_size [mublas_int] number of bytes per element in the matrix
• x pointer to vector on the device
• incx [mublas_int] specifies the increment for the elements of the vector
• y pointer to vector on the host
• incy [mublas_int] specifies the increment for the elements of the vector
• stream specifies the stream into which this transfer request is queued

mublasGetVectorAsync copies a vector from pinned host memory to device memory asynchronously. Memory on the host must be allocated with hipHostMalloc or the transfer will be synchronous.

mublasFree

mublasSetAtomicsMode

mublasSetVectorAsync

mublasGetAtomicsMode

mublasGetmudartVersion

mublasSetVector

mublasInit

mublasAlloc

mublasSetKernelStream

mublasSetLoggerCallback

mublasLoggerConfigure

function mublasGemmGroupedBatchedEx

mublasGemmGroupedBatchedEx(
    mublasHandle_t handle,
    const mublasOperation_t transa_array[],
    const mublasOperation_t transb_array[],
    const int               m_array[],
    const int               n_array[],
    const int               k_array[],
    const void*             alpha_array,
    const void* const       Aarray[],
    musaDataType_t          Atype,
    const int               lda_array[],
    const void* const       Barray[],
    musaDataType_t          Btype,
    const int               ldb_array[],
    const void*             beta_array,
    void* const             Carray[],
    musaDataType_t          Ctype,
    const int               ldc_array[],
    int                     group_count,
    const int               group_size[],
    mublasComputeType_t     computeType
    )

function 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

Parameters:

• handle: [mublasHandle_t] Handle to the mublas library context queue.
• transA: [mublasOperation_t] Specifies the form of $\text{op}(A)$.
• transB: [mublasOperation_t] Specifies the form of $\text{op}(B)$.
• m: [mublas_int] Matrix dimension $m$.
• n: [mublas_int] Matrix dimension $n$.
• k: [mublas_int] Matrix dimension $k$.
• alpha: [const void *] Device pointer or host pointer specifying the scalar $\alpha$. Same datatype as compute_type.
• a: [void *] Device pointer storing matrix $A$.
• a_type: [musaDataType_t] Specifies the datatype of matrix $A$.
• lda: [mublas_int] Specifies the leading dimension of $A$.
• b: [void *] Device pointer storing matrix $B$.
• b_type: [musaDataType_t] Specifies the datatype of matrix $B$.
• ldb: [mublas_int] Specifies the leading dimension of $B$.
• beta: [const void *] Device pointer or host pointer specifying the scalar $\beta$. Same datatype as compute_type.
• c: [void *] Device pointer storing matrix $C$.
• c_type: [musaDataType_t] Specifies the datatype of matrix $C$.
• ldc: [mublas_int] Specifies the leading dimension of $C$.
• compute_type: Specifies the datatype of computation.
• algo: [mublasGemmAlgo_t] Enumerant specifying the algorithm type.

gemm_ex performs one of the matrix-matrix operations:

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

where $\text{op}(X)$ is one of:

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

and $\alpha$ and $\beta$ are scalars. $A$, $B$, and $C$ are matrices, with $\text{op}(A)$ being an $m \times k$ matrix, $\text{op}(B)$ a $k \times n$ matrix, and $C$ an $m \times n$ matrix.

Supported types:

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

function 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

Parameters:

• handle [mublasHandle_t]: Handle to the mublas library context queue.
• transA [mublasOperation_t]: Specifies the form of $\text{op}(A)$.
• transB [mublasOperation_t]: Specifies the form of $\text{op}(B)$.
• m [mublas_int]: Number of rows of $\text{op}(A)$ and $C$.
• n [mublas_int]: Number of columns of $\text{op}(B)$ and $C$.
• k [mublas_int]: Number of columns of $\text{op}(A)$ and rows of $\text{op}(B)$.
• alpha [const void *]: Device or host pointer specifying the scalar $\alpha$. Must have the same datatype as compute_type.
• a [const void *]: Device pointer to the first matrix $A_1$.
• a_type [musaDataType_t]: Specifies the datatype of each matrix $A_i$.
• lda [mublas_int]: Specifies the leading dimension of each $A_i$.
• stride_a [mublas_stride]: Stride from the start of one $A_i$ matrix to the next $A_{i+1}$.
• b [const void *]: Device pointer to the first matrix $B_1$.
• b_type [musaDataType_t]: Specifies the datatype of each matrix $B_i$.
• ldb [mublas_int]: Specifies the leading dimension of each $B_i$.
• stride_b [mublas_stride]: Stride from the start of one $B_i$ matrix to the next $B_{i+1}$.
• beta [const void *]: Device or host pointer specifying the scalar $\beta$. Must have the same datatype as compute_type.
• c [void *]: Device pointer to the first matrix $C_1$.
• c_type [musaDataType_t]: Specifies the datatype of each matrix $C_i$.
• ldc [mublas_int]: Specifies the leading dimension of each $C_i$.
• stride_c [mublas_stride]: Stride from the start of one $C_i$ matrix to the next $C_{i+1}$.
• batch_count [mublas_int]: Number of GEMM operations in the batch.
• compute_type [mublasComputeType_t]: Specifies the datatype for computation.
• algo [mublasGemmAlgo_t]: Specifies the algorithm type.

gemm_strided_batched_ex performs one of the strided batched matrix-matrix operations:

$$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},$$

where $\text{op}(X)$ is one of:

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

$\alpha$ and $\beta$ are scalars, and $A$, $B$, $C$ are strided batched matrices, where:

• $\text{op}(A)$ is an $m \times k \times \text{batch\_count}$ strided batched matrix.
• $\text{op}(B)$ is a $k \times n \times \text{batch\_count}$ strided batched matrix.
• $C$ is an $m \times n \times \text{batch\_count}$ strided batched matrix.

Strided batched matrices are multiple matrices separated by a constant stride. The total number of matrices is specified by batch_count.

Supported types

The following types are supported:

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

function 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

Parameters

• handle [mublasHandle_t]
  Handle to the mublas library context queue.

• transA [mublasOperation_t]
  Specifies the form of $\text{op}(A)$.

• transB [mublasOperation_t]
  Specifies the form of $\text{op}(B)$.

• m [mublas_int]
  Matrix dimension $m$.

• n [mublas_int]
  Matrix dimension $n$.

• k [mublas_int]
  Matrix dimension $k$.

• alpha [const void *]
  Device pointer or host pointer specifying the scalar $\alpha$. Same datatype as compute_type.

• a [void *]
  Device pointer storing an array of pointers to each matrix $A_i$.

• a_type [musaDataType_t]
  Specifies the datatype of each matrix $A_i$.

• lda [mublas_int]
  Specifies the leading dimension of each $A_i$.

• b [void *]
  Device pointer storing an array of pointers to each matrix $B_i$.

• b_type [musaDataType_t]
  Specifies the datatype of each matrix $B_i$.

• ldb [mublas_int]
  Specifies the leading dimension of each $B_i$.

• beta [const void *]
  Device pointer or host pointer specifying the scalar $\beta$. Same datatype as compute_type.

• c [void *]
  Device array of device pointers to each matrix $C_i$.

• c_type [musaDataType_t]
  Specifies the datatype of each matrix $C_i$.

• ldc [mublas_int]
  Specifies the leading dimension of each $C_i$.

• batch_count [mublas_int]
  Number of GEMM operations in the batch.

• compute_type Specifies the datatype of computation.

• algo [mublasGemmAlgo_t]
  Enumerant specifying the algorithm type.

GemmBatchedEx performs one of the batched matrix-matrix operations:

$$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}.$$

Where:

• $\text{op}(X)$ is one of:

  • $\text{op}(X) = X$,
  • $\text{op}(X) = X^T$, or
  • $\text{op}(X) = X^H$.

• $\alpha$ and $\beta$ are scalars.

• $A$, $B$, and $C$ are batched pointers to matrices:

  • $\text{op}(A)$ is an $m \times k \times \text{batch\_count}$ batched matrix,
  • $\text{op}(B)$ is a $k \times n \times \text{batch\_count}$ batched matrix,
  • $C$ is an $m \times n \times \text{batch\_count}$ batched matrix.

The batched matrices are stored as an array of pointers, with the number of pointers equal to $\text{batch\_count}$.

Supported types

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