muSOLVER API 参考

目录

• File musolverDn.h
• File musolverMg.h
• File musolverRf.h
• File musolverSp.h
• File musolver.h
• File musolver_common.h

---

File musolverDn.h

Location: musolverDn.h

musolverDn.h provides dense Lapack functionality for musa_toolkit platform.

Includes

• musolver_common.h

Included by

• musolver.h
• musolverMg.h

Function musolverDnSorgqr

musolverStatus_t MUSOLVERAPI musolverDnSorgqr(musolverDnHandle_t handle, int m, int n, int k, float *A, int lda, float *tau, float *work, int lwork, int *info)

ORGQR generates an m-by-n Matrix Q with orthonormal columns.

(This is the blocked version of the algorithm).

The matrix Q is defined as the first n columns of the product of k Householder reflectors of order m

formula {"type":"element","name":"formula","attributes":{"id":"6"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_k\n \\]"}]}

The Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} and scalars formula {"type":"element","name":"formula","attributes":{"id":"9"},"children":[{"type":"text","text":"$\\text{ipiv}[i]$"}]}, as returned by GEQRF.

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of the matrix Q.
• n: int. 0 <= n <= m.
  The number of columns of the matrix Q.
• k: int. 0 <= k <= n.
  The number of Householder reflectors.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A as returned by GEQRF, with the Householder vectors in the first k columns. On exit, the computed matrix Q.
• lda: int. lda >= m.
  Specifies the leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension at least k.
  The Householder scalars as returned by GEQRF.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• float * A
• int lda
• float * tau
• float * work
• int lwork
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDorgqr

musolverStatus_t MUSOLVERAPI musolverDnDorgqr(musolverDnHandle_t handle, int m, int n, int k, double *A, int lda, double *tau, double *work, int lwork, int *info)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• double * A
• int lda
• double * tau
• double * work
• int lwork
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCungqr

musolverStatus_t MUSOLVERAPI musolverDnCungqr(musolverDnHandle_t handle, int m, int n, int k, muComplex *A, int lda, muComplex *tau, muComplex *work, int lwork, int *info)

UNGQR generates an m-by-n complex Matrix Q with orthonormal columns.

(This is the blocked version of the algorithm).

The matrix Q is defined as the first n columns of the product of k Householder reflectors of order m

formula {"type":"element","name":"formula","attributes":{"id":"6"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_k\n \\]"}]}

Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} and scalars formula {"type":"element","name":"formula","attributes":{"id":"9"},"children":[{"type":"text","text":"$\\text{ipiv}[i]$"}]}, as returned by GEQRF.

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of the matrix Q.
• n: int. 0 <= n <= m.
  The number of columns of the matrix Q.
• k: int. 0 <= k <= n.
  The number of Householder reflectors.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A as returned by GEQRF, with the Householder vectors in the first k columns. On exit, the computed matrix Q.
• lda: int. lda >= m.
  Specifies the leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension at least k.
  The Householder scalars as returned by GEQRF.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• muComplex * A
• int lda
• muComplex * tau
• muComplex * work
• int lwork
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZungqr

musolverStatus_t MUSOLVERAPI musolverDnZungqr(musolverDnHandle_t handle, int m, int n, int k, muDoubleComplex *A, int lda, muDoubleComplex *tau, muDoubleComplex *work, int lwork, int *info)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• muDoubleComplex * A
• int lda
• muDoubleComplex * tau
• muDoubleComplex * work
• int lwork
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSorgqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSorgqr_bufferSize(musolverDnHandle_t handle, int m, int n, int k, const float *A, int lda, const float *tau, int *lwork)

get buffer size to generate orthogonal matrix Q.

{@

This function computes the required workspace size for ORGQR operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• const float * A
• int lda
• const float * tau
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDorgqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDorgqr_bufferSize(musolverDnHandle_t handle, int m, int n, int k, const double *A, int lda, const double *tau, int *lwork)

get buffer size to generate orthogonal matrix Q.

{@

This function computes the required workspace size for ORGQR operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• const double * A
• int lda
• const double * tau
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCungqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCungqr_bufferSize(musolverDnHandle_t handle, int m, int n, int k, const muComplex *A, int lda, const muComplex *tau, int *lwork)

get buffer size to generate unitary matrix Q.

{@

This function computes the required workspace size for UNGQR operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• const muComplex * A
• int lda
• const muComplex * tau
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZungqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZungqr_bufferSize(musolverDnHandle_t handle, int m, int n, int k, const muDoubleComplex *A, int lda, const muDoubleComplex *tau, int *lwork)

get buffer size to generate unitary matrix Q.

{@

This function computes the required workspace size for UNGQR operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int k
• const muDoubleComplex * A
• int lda
• const muDoubleComplex * tau
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSorgbr

musolverStatus_t MUSOLVERAPI musolverDnSorgbr(musolverDnHandle_t handle, const mublasStorev storev, const int m, const int n, const int k, float *A, const int lda, float *ipiv)

ORGBR generates an m-by-n Matrix Q with orthonormal rows or columns.

If storev is column-wise, then the matrix Q has orthonormal columns. If m >= k, Q is defined as the first n columns of the product of k Householder reflectors of order m

formula {"type":"element","name":"formula","attributes":{"id":"6"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_k\n \\]"}]}

If m < k, Q is defined as the product of Householder reflectors of order m

formula {"type":"element","name":"formula","attributes":{"id":"10"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_{m-1}\n \\]"}]}

On the other hand, if storev is row-wise, then the matrix Q has orthonormal rows. If n > k, Q is defined as the first m rows of the product of k Householder reflectors of order n

formula {"type":"element","name":"formula","attributes":{"id":"11"},"children":[{"type":"text","text":"\\[\n Q = H_kH_{k-1}\\cdots H_1\n \\]"}]}

If n <= k, Q is defined as the product of Householder reflectors of order n

formula {"type":"element","name":"formula","attributes":{"id":"12"},"children":[{"type":"text","text":"\\[\n Q = H_{n-1}H_{n-2}\\cdots H_1\n \\]"}]}

The Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} and scalars formula {"type":"element","name":"formula","attributes":{"id":"9"},"children":[{"type":"text","text":"$\\text{ipiv}[i]$"}]}, as returned by GEBRD in its arguments A and tauq or taup.

Parameters:

• handle: musolverDnHandle_t .
• storev: mublasStorev.
  Specifies whether to work column-wise or row-wise.
• m: int. m >= 0.
  The number of rows of the matrix Q. If row-wise, then min(n,k) <= m <= n.
• n: int. n >= 0.
  The number of columns of the matrix Q. If column-wise, then min(m,k) <= n <= m.
• k: int. k >= 0.
  The number of columns (if storev is column-wise) or rows (if row-wise) of the original matrix reduced by GEBRD.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the Householder vectors as returned by GEBRD. On exit, the computed matrix Q.
• lda: int. lda >= m.
  Specifies the leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension min(m,k) if column-wise, or min(n,k) if row-wise.
  The Householder scalars as returned by GEBRD.

Parameters:

• musolverDnHandle_t handle
• const mublasStorev storev
• const int m
• const int n
• const int k
• float * A
• const int lda
• float * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDorgbr

musolverStatus_t MUSOLVERAPI musolverDnDorgbr(musolverDnHandle_t handle, const mublasStorev storev, const int m, const int n, const int k, double *A, const int lda, double *ipiv)

Parameters:

• musolverDnHandle_t handle
• const mublasStorev storev
• const int m
• const int n
• const int k
• double * A
• const int lda
• double * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCungbr

musolverStatus_t MUSOLVERAPI musolverDnCungbr(musolverDnHandle_t handle, const mublasStorev storev, const int m, const int n, const int k, muComplex *A, const int lda, muComplex *ipiv)

UNGBR generates an m-by-n complex Matrix Q with orthonormal rows or columns.

If storev is column-wise, then the matrix Q has orthonormal columns. If m >= k, Q is defined as the first n columns of the product of k Householder reflectors of order m

formula {"type":"element","name":"formula","attributes":{"id":"6"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_k\n \\]"}]}

If m < k, Q is defined as the product of Householder reflectors of order m

formula {"type":"element","name":"formula","attributes":{"id":"10"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_{m-1}\n \\]"}]}

On the other hand, if storev is row-wise, then the matrix Q has orthonormal rows. If n > k, Q is defined as the first m rows of the product of k Householder reflectors of order n

formula {"type":"element","name":"formula","attributes":{"id":"11"},"children":[{"type":"text","text":"\\[\n Q = H_kH_{k-1}\\cdots H_1\n \\]"}]}

If n <= k, Q is defined as the product of Householder reflectors of order n

formula {"type":"element","name":"formula","attributes":{"id":"12"},"children":[{"type":"text","text":"\\[\n Q = H_{n-1}H_{n-2}\\cdots H_1\n \\]"}]}

The Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} and scalars formula {"type":"element","name":"formula","attributes":{"id":"9"},"children":[{"type":"text","text":"$\\text{ipiv}[i]$"}]}, as returned by GEBRD in its arguments A and tauq or taup.

Parameters:

• handle: musolverDnHandle_t .
• storev: mublasStorev.
  Specifies whether to work column-wise or row-wise.
• m: int. m >= 0.
  The number of rows of the matrix Q. If row-wise, then min(n,k) <= m <= n.
• n: int. n >= 0.
  The number of columns of the matrix Q. If column-wise, then min(m,k) <= n <= m.
• k: int. k >= 0.
  The number of columns (if storev is column-wise) or rows (if row-wise) of the original matrix reduced by GEBRD.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the Householder vectors as returned by GEBRD. On exit, the computed matrix Q.
• lda: int. lda >= m.
  Specifies the leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension min(m,k) if column-wise, or min(n,k) if row-wise.
  The Householder scalars as returned by GEBRD.

Parameters:

• musolverDnHandle_t handle
• const mublasStorev storev
• const int m
• const int n
• const int k
• muComplex * A
• const int lda
• muComplex * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZungbr

musolverStatus_t MUSOLVERAPI musolverDnZungbr(musolverDnHandle_t handle, const mublasStorev storev, const int m, const int n, const int k, muDoubleComplex *A, const int lda, muDoubleComplex *ipiv)

Parameters:

• musolverDnHandle_t handle
• const mublasStorev storev
• const int m
• const int n
• const int k
• muDoubleComplex * A
• const int lda
• muDoubleComplex * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSorgtr

musolverStatus_t MUSOLVERAPI musolverDnSorgtr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *ipiv)

ORGTR generates an n-by-n orthogonal Matrix Q.

Q is defined as the product of n-1 Householder reflectors of order n. If uplo indicates upper, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"12"},"children":[{"type":"text","text":"\\[\n Q = H_{n-1}H_{n-2}\\cdots H_1\n \\]"}]}

On the other hand, if uplo indicates lower, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"13"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_{n-1}\n \\]"}]}

The Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} and scalars formula {"type":"element","name":"formula","attributes":{"id":"9"},"children":[{"type":"text","text":"$\\text{ipiv}[i]$"}]}, as returned by SYTRD in its arguments A and tau.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the SYTRD factorization was upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of the matrix Q.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the Householder vectors as returned by SYTRD. On exit, the computed matrix Q.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension n-1.
  The Householder scalars as returned by SYTRD.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDorgtr

musolverStatus_t MUSOLVERAPI musolverDnDorgtr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *ipiv)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCungtr

musolverStatus_t MUSOLVERAPI musolverDnCungtr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, muComplex *ipiv)

UNGTR generates an n-by-n unitary Matrix Q.

Q is defined as the product of n-1 Householder reflectors of order n. If uplo indicates upper, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"12"},"children":[{"type":"text","text":"\\[\n Q = H_{n-1}H_{n-2}\\cdots H_1\n \\]"}]}

On the other hand, if uplo indicates lower, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"13"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_{n-1}\n \\]"}]}

The Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} and scalars formula {"type":"element","name":"formula","attributes":{"id":"9"},"children":[{"type":"text","text":"$\\text{ipiv}[i]$"}]}, as returned by HETRD in its arguments A and tau.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the HETRD factorization was upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of the matrix Q.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the Householder vectors as returned by HETRD. On exit, the computed matrix Q.
• lda: int. lda >= m.
  Specifies the leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension n-1.
  The Householder scalars as returned by HETRD.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• muComplex * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZungtr

musolverStatus_t MUSOLVERAPI musolverDnZungtr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, muDoubleComplex *ipiv)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• muDoubleComplex * ipiv

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSormqr

musolverStatus_t MUSOLVERAPI musolverDnSormqr(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, float *A, int lda, float *tau, float *C, int ldc, float *work, int lwork, int *devInfo)

ORMQR multiplies a matrix Q with orthonormal columns by a general m-by-n matrix C.

(This is the blocked version of the algorithm).

The matrix Q is applied in one of the following forms, depending on the values of side and trans:

formula {"type":"element","name":"formula","attributes":{"id":"14"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n QC & \\: \\text{No transpose from the left,}\\\\\n Q^TC & \\: \\text{Transpose from the left,}\\\\\n CQ & \\: \\text{No transpose from the right, and}\\\\\n CQ^T & \\: \\text{Transpose from the right.}\n \\end{array}\n \\]"}]}

Q is defined as the product of k Householder reflectors

formula {"type":"element","name":"formula","attributes":{"id":"6"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_k\n \\]"}]}

of order m if applying from the left, or n if applying from the right. Q is never stored, it is calculated from the Householder vectors and scalars returned by the QR factorization GEQRF.

Parameters:

• handle: musolverDnHandle_t .
• side: mublasSideMode_t.
  Specifies from which side to apply Q.
• trans: mublasOperation_t.
  Specifies whether the matrix Q or its transpose is to be applied.
• m: int. m >= 0.
  Number of rows of matrix C.
• n: int. n >= 0.
  Number of columns of matrix C.
• k: int. k >= 0; k <= m if side is left, k <= n if side is right.
  The number of Householder reflectors that form Q.
• A: pointer to type. Array on the GPU of size lda*k.
  The Householder vectors as returned by GEQRF in the first k columns of its argument A.
• lda: int. lda >= m if side is left, or lda >= n if side is right.
  Leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension at least k.
  The Householder scalars as returned by GEQRF.
• C: pointer to type. Array on the GPU of size ldcn.
  On entry, the matrix C. On exit, it is overwritten with QC, C*Q, Q'C, or CQ'.
• ldc: int. ldc >= m.
  Leading dimension of C.

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• float * A
• int lda
• float * tau
• float * C
• int ldc
• float * work
• int lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDormqr

musolverStatus_t MUSOLVERAPI musolverDnDormqr(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, double *A, int lda, double *tau, double *C, int ldc, double *work, int lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• double * A
• int lda
• double * tau
• double * C
• int ldc
• double * work
• int lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSormqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSormqr_bufferSize(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, const float *A, int lda, const float *tau, const float *C, int ldc, int *lwork)

get buffer size to compute Q**Tb in solve min||Ax = b||.

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• const float * A
• int lda
• const float * tau
• const float * C
• int ldc
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDormqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDormqr_bufferSize(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, const double *A, int lda, const double *tau, const double *C, int ldc, int *lwork)

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• const double * A
• int lda
• const double * tau
• const double * C
• int ldc
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCunmqr

musolverStatus_t MUSOLVERAPI musolverDnCunmqr(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, muComplex *A, int lda, muComplex *tau, muComplex *C, int ldc, muComplex *work, int lwork, int *devInfo)

UNMQR multiplies a complex matrix Q with orthonormal columns by a general m-by-n matrix C.

(This is the blocked version of the algorithm).

The matrix Q is applied in one of the following forms, depending on the values of side and trans:

formula {"type":"element","name":"formula","attributes":{"id":"15"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n QC & \\: \\text{No transpose from the left,}\\\\\n Q^HC & \\: \\text{Conjugate transpose from the left,}\\\\\n CQ & \\: \\text{No transpose from the right, and}\\\\\n CQ^H & \\: \\text{Conjugate transpose from the right.}\n \\end{array}\n \\]"}]}

Q is defined as the product of k Householder reflectors

formula {"type":"element","name":"formula","attributes":{"id":"6"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_k\n \\]"}]}

of order m if applying from the left, or n if applying from the right. Q is never stored, it is calculated from the Householder vectors and scalars returned by the QR factorization GEQRF.

Parameters:

• handle: musolverDnHandle_t .
• side: mublasSideMode_t.
  Specifies from which side to apply Q.
• trans: mublasOperation_t.
  Specifies whether the matrix Q or its conjugate transpose is to be applied.
• m: int. m >= 0.
  Number of rows of matrix C.
• n: int. n >= 0.
  Number of columns of matrix C.
• k: int. k >= 0; k <= m if side is left, k <= n if side is right.
  The number of Householder reflectors that form Q.
• A: pointer to type. Array on the GPU of size lda*k.
  The Householder vectors as returned by GEQRF in the first k columns of its argument A.
• lda: int. lda >= m if side is left, or lda >= n if side is right.
  Leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension at least k.
  The Householder scalars as returned by GEQRF.
• C: pointer to type. Array on the GPU of size ldcn.
  On entry, the matrix C. On exit, it is overwritten with QC, C*Q, Q'C, or CQ'.
• ldc: int. ldc >= m.
  Leading dimension of C.

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• muComplex * A
• int lda
• muComplex * tau
• muComplex * C
• int ldc
• muComplex * work
• int lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZunmqr

musolverStatus_t MUSOLVERAPI musolverDnZunmqr(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, muDoubleComplex *A, int lda, muDoubleComplex *tau, muDoubleComplex *C, int ldc, muDoubleComplex *work, int lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• muDoubleComplex * A
• int lda
• muDoubleComplex * tau
• muDoubleComplex * C
• int ldc
• muDoubleComplex * work
• int lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCunmqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCunmqr_bufferSize(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, const muComplex *A, int lda, const muComplex *tau, const muComplex *C, int ldc, int *lwork)

get buffer size to compute Q**Tb in solve min||Ax = b||.

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• const muComplex * A
• int lda
• const muComplex * tau
• const muComplex * C
• int ldc
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZunmqr_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZunmqr_bufferSize(musolverDnHandle_t handle, mublasSideMode_t side, mublasOperation_t trans, int m, int n, int k, const muDoubleComplex *A, int lda, const muDoubleComplex *tau, const muDoubleComplex *C, int ldc, int *lwork)

Parameters:

• musolverDnHandle_t handle
• mublasSideMode_t side
• mublasOperation_t trans
• int m
• int n
• int k
• const muDoubleComplex * A
• int lda
• const muDoubleComplex * tau
• const muDoubleComplex * C
• int ldc
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSormtr

musolverStatus_t MUSOLVERAPI musolverDnSormtr(musolverDnHandle_t handle, const mublasSideMode_t side, const mublasFillMode_t uplo, const mublasOperation_t trans, const int m, const int n, float *A, const int lda, float *ipiv, float *C, const int ldc)

ORMTR multiplies an orthogonal matrix Q by a general m-by-n matrix C.

The matrix Q is applied in one of the following forms, depending on the values of side and trans:

formula {"type":"element","name":"formula","attributes":{"id":"14"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n QC & \\: \\text{No transpose from the left,}\\\\\n Q^TC & \\: \\text{Transpose from the left,}\\\\\n CQ & \\: \\text{No transpose from the right, and}\\\\\n CQ^T & \\: \\text{Transpose from the right.}\n \\end{array}\n \\]"}]}

The order q of the orthogonal matrix Q is q = m if applying from the left, or q = n if applying from the right.

Q is defined as a product of q-1 Householder reflectors. If uplo indicates upper, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"16"},"children":[{"type":"text","text":"\\[\n Q = H_{q-1}H_{q-2}\\cdots H_1.\n \\]"}]}

On the other hand, if uplo indicates lower, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"17"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_{q-1}\n \\]"}]}

The Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors and scalars as returned by SYTRD in its arguments A and tau.

Parameters:

• handle: musolverDnHandle_t .
• side: mublasSideMode_t.
  Specifies from which side to apply Q.
• uplo: mublasFillMode_t .
  Specifies whether the SYTRD factorization was upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• trans: mublasOperation_t.
  Specifies whether the matrix Q or its transpose is to be applied.
• m: int. m >= 0.
  Number of rows of matrix C.
• n: int. n >= 0.
  Number of columns of matrix C.
• A: pointer to type. Array on the GPU of size lda*q.
  On entry, the Householder vectors as returned by SYTRD.
• lda: int. lda >= q.
  Leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension at least q-1.
  The Householder scalars as returned by SYTRD.
• C: pointer to type. Array on the GPU of size ldcn.
  On entry, the matrix C. On exit, it is overwritten with QC, C*Q, Q'C, or CQ'.
• ldc: int. ldc >= m.
  Leading dimension of C.

Parameters:

• musolverDnHandle_t handle
• const mublasSideMode_t side
• const mublasFillMode_t uplo
• const mublasOperation_t trans
• const int m
• const int n
• float * A
• const int lda
• float * ipiv
• float * C
• const int ldc

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDormtr

musolverStatus_t MUSOLVERAPI musolverDnDormtr(musolverDnHandle_t handle, const mublasSideMode_t side, const mublasFillMode_t uplo, const mublasOperation_t trans, const int m, const int n, double *A, const int lda, double *ipiv, double *C, const int ldc)

Parameters:

• musolverDnHandle_t handle
• const mublasSideMode_t side
• const mublasFillMode_t uplo
• const mublasOperation_t trans
• const int m
• const int n
• double * A
• const int lda
• double * ipiv
• double * C
• const int ldc

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCunmtr

musolverStatus_t MUSOLVERAPI musolverDnCunmtr(musolverDnHandle_t handle, const mublasSideMode_t side, const mublasFillMode_t uplo, const mublasOperation_t trans, const int m, const int n, muComplex *A, const int lda, muComplex *ipiv, muComplex *C, const int ldc)

UNMTR multiplies a unitary matrix Q by a general m-by-n matrix C.

The matrix Q is applied in one of the following forms, depending on the values of side and trans:

formula {"type":"element","name":"formula","attributes":{"id":"15"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n QC & \\: \\text{No transpose from the left,}\\\\\n Q^HC & \\: \\text{Conjugate transpose from the left,}\\\\\n CQ & \\: \\text{No transpose from the right, and}\\\\\n CQ^H & \\: \\text{Conjugate transpose from the right.}\n \\end{array}\n \\]"}]}

The order q of the unitary matrix Q is q = m if applying from the left, or q = n if applying from the right.

Q is defined as a product of q-1 Householder reflectors. If uplo indicates upper, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"16"},"children":[{"type":"text","text":"\\[\n Q = H_{q-1}H_{q-2}\\cdots H_1.\n \\]"}]}

On the other hand, if uplo indicates lower, then Q has the form

formula {"type":"element","name":"formula","attributes":{"id":"17"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_{q-1}\n \\]"}]}

The Householder matrices formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} are never stored, they are computed from its corresponding Householder vectors and scalars as returned by HETRD in its arguments A and tau.

Parameters:

• handle: musolverDnHandle_t .
• side: mublasSideMode_t.
  Specifies from which side to apply Q.
• uplo: mublasFillMode_t .
  Specifies whether the HETRD factorization was upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• trans: mublasOperation_t.
  Specifies whether the matrix Q or its conjugate transpose is to be applied.
• m: int. m >= 0.
  Number of rows of matrix C.
• n: int. n >= 0.
  Number of columns of matrix C.
• A: pointer to type. Array on the GPU of size lda*q.
  On entry, the Householder vectors as returned by HETRD.
• lda: int. lda >= q.
  Leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension at least q-1.
  The Householder scalars as returned by HETRD.
• C: pointer to type. Array on the GPU of size ldcn.
  On entry, the matrix C. On exit, it is overwritten with QC, C*Q, Q'C, or CQ'.
• ldc: int. ldc >= m.
  Leading dimension of C.

Parameters:

• musolverDnHandle_t handle
• const mublasSideMode_t side
• const mublasFillMode_t uplo
• const mublasOperation_t trans
• const int m
• const int n
• muComplex * A
• const int lda
• muComplex * ipiv
• muComplex * C
• const int ldc

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZunmtr

musolverStatus_t MUSOLVERAPI musolverDnZunmtr(musolverDnHandle_t handle, const mublasSideMode_t side, const mublasFillMode_t uplo, const mublasOperation_t trans, const int m, const int n, muDoubleComplex *A, const int lda, muDoubleComplex *ipiv, muDoubleComplex *C, const int ldc)

Parameters:

• musolverDnHandle_t handle
• const mublasSideMode_t side
• const mublasFillMode_t uplo
• const mublasOperation_t trans
• const int m
• const int n
• muDoubleComplex * A
• const int lda
• muDoubleComplex * ipiv
• muDoubleComplex * C
• const int ldc

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSbdsqr

musolverStatus_t MUSOLVERAPI musolverDnSbdsqr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, const int nv, const int nu, const int nc, float *D, float *E, float *V, const int ldv, float *U, const int ldu, float *C, const int ldc, int *info)

BDSQR computes the singular value decomposition (SVD) of an n-by-n bidiagonal matrix B, using the implicit QR algorithm.

The SVD of B has the form:

formula {"type":"element","name":"formula","attributes":{"id":"18"},"children":[{"type":"text","text":"\\[\n B = QSP'\n \\]"}]}

where S is the n-by-n diagonal matrix of singular values of B, the columns of Q are the left singular vectors of B, and the columns of P are its right singular vectors.

The computation of the singular vectors is optional; this function accepts input matrices U (of size nu-by-n) and V (of size n-by-nv) that are overwritten with formula {"type":"element","name":"formula","attributes":{"id":"19"},"children":[{"type":"text","text":"$UQ$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"20"},"children":[{"type":"text","text":"$P'V$"}]}. If nu = 0 no left vectors are computed; if nv = 0 no right vectors are computed.

Optionally, this function can also compute formula {"type":"element","name":"formula","attributes":{"id":"21"},"children":[{"type":"text","text":"$Q'C$"}]} for a given n-by-nc input matrix C.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether B is upper or lower bidiagonal.
• n: int. n >= 0.
  The number of rows and columns of matrix B.
• nv: int. nv >= 0.
  The number of columns of matrix V.
• nu: int. nu >= 0.
  The number of rows of matrix U.
• nc: int. nu >= 0.
  The number of columns of matrix C.
• D: pointer to real type. Array on the GPU of dimension n.
  On entry, the diagonal elements of B. On exit, if info = 0, the singular values of B in decreasing order; if info > 0, the diagonal elements of a bidiagonal matrix orthogonally equivalent to B.
• E: pointer to real type. Array on the GPU of dimension n-1.
  On entry, the off-diagonal elements of B. On exit, if info > 0, the off-diagonal elements of a bidiagonal matrix orthogonally equivalent to B (if info = 0 this matrix converges to zero).
• V: pointer to type. Array on the GPU of dimension ldv*nv.
  On entry, the matrix V. On exit, it is overwritten with P'*V. (Not referenced if nv = 0).
• ldv: int. ldv >= n if nv > 0, or ldv >=1 if nv = 0.
  The leading dimension of V.
• U: pointer to type. Array on the GPU of dimension ldun.
  On entry, the matrix U. On exit, it is overwritten with UQ. (Not referenced if nu = 0).
• ldu: int. ldu >= nu.
  The leading dimension of U.
• C: pointer to type. Array on the GPU of dimension ldc*nc.
  On entry, the matrix C. On exit, it is overwritten with Q'*C. (Not referenced if nc = 0).
• ldc: int. ldc >= n if nc > 0, or ldc >=1 if nc = 0.
  The leading dimension of C.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, i elements of E have not converged to zero.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• const int nv
• const int nu
• const int nc
• float * D
• float * E
• float * V
• const int ldv
• float * U
• const int ldu
• float * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDbdsqr

musolverStatus_t MUSOLVERAPI musolverDnDbdsqr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, const int nv, const int nu, const int nc, double *D, double *E, double *V, const int ldv, double *U, const int ldu, double *C, const int ldc, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• const int nv
• const int nu
• const int nc
• double * D
• double * E
• double * V
• const int ldv
• double * U
• const int ldu
• double * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCbdsqr

musolverStatus_t MUSOLVERAPI musolverDnCbdsqr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, const int nv, const int nu, const int nc, float *D, float *E, muComplex *V, const int ldv, muComplex *U, const int ldu, muComplex *C, const int ldc, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• const int nv
• const int nu
• const int nc
• float * D
• float * E
• muComplex * V
• const int ldv
• muComplex * U
• const int ldu
• muComplex * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZbdsqr

musolverStatus_t MUSOLVERAPI musolverDnZbdsqr(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, const int nv, const int nu, const int nc, double *D, double *E, muDoubleComplex *V, const int ldv, muDoubleComplex *U, const int ldu, muDoubleComplex *C, const int ldc, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• const int nv
• const int nu
• const int nc
• double * D
• double * E
• muDoubleComplex * V
• const int ldv
• muDoubleComplex * U
• const int ldu
• muDoubleComplex * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSstedc

musolverStatus_t MUSOLVERAPI musolverDnSstedc(musolverDnHandle_t handle, const mublasEvect evect, const int n, float *D, float *E, float *C, const int ldc, int *info)

STEDC computes the eigenvalues and (optionally) eigenvectors of a symmetric tridiagonal matrix.

This function uses the divide and conquer method to compute the eigenvectors. The eigenvalues are returned in increasing order.

The matrix is not represented explicitly, but rather as the array of diagonal elements D and the array of symmetric off-diagonal elements E. When D and E correspond to the tridiagonal form of a full symmetric/Hermitian matrix, as returned by, e.g., SYTRD or HETRD, the eigenvectors of the original matrix can also be computed, depending on the value of evect.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies how the eigenvectors are computed.
• n: int. n >= 0.
  The number of rows and columns of the tridiagonal matrix.
• D: pointer to real type. Array on the GPU of dimension n.
  On entry, the diagonal elements of the tridiagonal matrix. On exit, if info = 0, the eigenvalues in increasing order.
• E: pointer to real type. Array on the GPU of dimension n-1.
  On entry, the off-diagonal elements of the tridiagonal matrix. On exit, if info = 0, the values of this array are destroyed.
• C: pointer to type. Array on the GPU of dimension ldc*n.
  On entry, if evect is original, the orthogonal/unitary matrix used for the reduction to tridiagonal form as returned by, e.g., ORGTR or UNGTR. On exit, if info = 0, it is overwritten with the eigenvectors of the original symmetric/Hermitian matrix (if evect is original), or the eigenvectors of the tridiagonal matrix (if evect is tridiagonal). (Not referenced if evect is none).
• ldc: int. ldc >= n if evect is original or tridiagonal.
  Specifies the leading dimension of C. (Not referenced if evect is none).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, STEDC failed to compute an eigenvalue on the sub-matrix formed by the rows and columns info/(n+1) through mod(info,n+1).

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const int n
• float * D
• float * E
• float * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDstedc

musolverStatus_t MUSOLVERAPI musolverDnDstedc(musolverDnHandle_t handle, const mublasEvect evect, const int n, double *D, double *E, double *C, const int ldc, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const int n
• double * D
• double * E
• double * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCstedc

musolverStatus_t MUSOLVERAPI musolverDnCstedc(musolverDnHandle_t handle, const mublasEvect evect, const int n, float *D, float *E, muComplex *C, const int ldc, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const int n
• float * D
• float * E
• muComplex * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZstedc

musolverStatus_t MUSOLVERAPI musolverDnZstedc(musolverDnHandle_t handle, const mublasEvect evect, const int n, double *D, double *E, muDoubleComplex *C, const int ldc, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const int n
• double * D
• double * E
• muDoubleComplex * C
• const int ldc
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetrf

musolverStatus_t MUSOLVERAPI musolverDnSgetrf(musolverDnHandle_t handle, int m, int n, float *A, int lda, float *Workspace, int *devIpiv, int *devInfo)

GETRF computes the LU factorization of a general m-by-n matrix A using partial pivoting with row interchanges.

(This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without muBLAS calls could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the "Tuning muSOLVER performance" section of the Library Design Guide).

The factorization has the form

formula {"type":"element","name":"formula","attributes":{"id":"22"},"children":[{"type":"text","text":"\\[\n A = PLU\n \\]"}]}

where P is a permutation matrix, L is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and U is upper triangular (upper trapezoidal if m < n).

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of the matrix A.
• n: int. n >= 0.
  The number of columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the m-by-n matrix A to be factored. On exit, the factors L and U from the factorization. The unit diagonal elements of L are not stored.
• lda: int. lda >= m.
  Specifies the leading dimension of A.
• ipiv: pointer to int. Array on the GPU of dimension min(m,n).
  The vector of pivot indices. Elements of ipiv are 1-based indices. For 1 <= i <= min(m,n), the row i of the matrix was interchanged with row ipiv[i]. Matrix P of the factorization can be derived from ipiv.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, U is singular. U[i,i] is the first zero pivot.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• float * A
• int lda
• float * Workspace
• int * devIpiv
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetrf

musolverStatus_t MUSOLVERAPI musolverDnDgetrf(musolverDnHandle_t handle, int m, int n, double *A, int lda, double *Workspace, int *devIpiv, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• double * A
• int lda
• double * Workspace
• int * devIpiv
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetrf

musolverStatus_t MUSOLVERAPI musolverDnCgetrf(musolverDnHandle_t handle, int m, int n, muComplex *A, int lda, muComplex *Workspace, int *devIpiv, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muComplex * A
• int lda
• muComplex * Workspace
• int * devIpiv
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetrf

musolverStatus_t MUSOLVERAPI musolverDnZgetrf(musolverDnHandle_t handle, int m, int n, muDoubleComplex *A, int lda, muDoubleComplex *Workspace, int *devIpiv, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muDoubleComplex * A
• int lda
• muDoubleComplex * Workspace
• int * devIpiv
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSgetrf_bufferSize(musolverDnHandle_t handle, int m, int n, float *A, int lda, int *Lwork)

get buffer size to compute LU factorization.

{@

This function computes the required workspace size for GETRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• float * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDgetrf_bufferSize(musolverDnHandle_t handle, int m, int n, double *A, int lda, int *Lwork)

get buffer size to compute LU factorization.

{@

This function computes the required workspace size for GETRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• double * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCgetrf_bufferSize(musolverDnHandle_t handle, int m, int n, muComplex *A, int lda, int *Lwork)

get buffer size to compute LU factorization.

{@

This function computes the required workspace size for GETRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muComplex * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZgetrf_bufferSize(musolverDnHandle_t handle, int m, int n, muDoubleComplex *A, int lda, int *Lwork)

get buffer size to compute LU factorization.

{@

This function computes the required workspace size for GETRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muDoubleComplex * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetrfBatched

musolverStatus_t MUSOLVERAPI musolverDnSgetrfBatched(musolverDnHandle_t handle, const int m, const int n, float *const A[], const int lda, float *buffer, int *ipiv, const int strideP, int *info, const int batch_count)

GETRF_BATCHED computes the LU factorization of a batch of general m-by-n matrices using partial pivoting with row interchanges.

(This is the blocked Level-3-BLAS version of the algorithm. An optimized internal implementation without muBLAS calls could be executed with mid-size matrices if optimizations are enabled (default option). For more details, see the "Tuning muSOLVER performance" section of the Library Design Guide).

The factorization of matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} in the batch has the form

formula {"type":"element","name":"formula","attributes":{"id":"24"},"children":[{"type":"text","text":"\\[\n A_j = P_jL_jU_j\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"25"},"children":[{"type":"text","text":"$P_j$"}]} is a permutation matrix, formula {"type":"element","name":"formula","attributes":{"id":"26"},"children":[{"type":"text","text":"$L_j$"}]} is lower triangular with unit diagonal elements (lower trapezoidal if m > n), and formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} is upper triangular (upper trapezoidal if m < n).

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of all matrices A_j in the batch.
• n: int. n >= 0.
  The number of columns of all matrices A_j in the batch.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the m-by-n matrices A_j to be factored. On exit, the factors L_j and U_j from the factorizations. The unit diagonal elements of L_j are not stored.
• lda: int. lda >= m.
  Specifies the leading dimension of matrices A_j.
• ipiv: pointer to int. Array on the GPU (the size depends on the value of strideP).
  Contains the vectors of pivot indices ipiv_j (corresponding to A_j). Dimension of ipiv_j is min(m,n). Elements of ipiv_j are 1-based indices. For each instance A_j in the batch and for 1 <= i <= min(m,n), the row i of the matrix A_j was interchanged with row ipiv_j[i]. Matrix P_j of the factorization can be derived from ipiv_j.
• strideP: int.
  Stride from the start of one vector ipiv_j to the next one ipiv_(j+1). There is no restriction for the value of strideP. Normal use case is strideP >= min(m,n).
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for factorization of A_j. If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• float *const A
• const int lda
• float * buffer
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetrfBatched

musolverStatus_t MUSOLVERAPI musolverDnDgetrfBatched(musolverDnHandle_t handle, const int m, const int n, double *const A[], const int lda, double *buffer, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• double *const A
• const int lda
• double * buffer
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetrfBatched

musolverStatus_t MUSOLVERAPI musolverDnCgetrfBatched(musolverDnHandle_t handle, const int m, const int n, muComplex *const A[], const int lda, muComplex *buffer, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muComplex *const A
• const int lda
• muComplex * buffer
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetrfBatched

musolverStatus_t MUSOLVERAPI musolverDnZgetrfBatched(musolverDnHandle_t handle, const int m, const int n, muDoubleComplex *const A[], const int lda, muDoubleComplex *buffer, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muDoubleComplex *const A
• const int lda
• muDoubleComplex * buffer
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetrfBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSgetrfBatched_bufferSize(musolverDnHandle_t handle, const int m, const int n, float *const A[], const int lda, const int batch_count, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• float *const A
• const int lda
• const int batch_count
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetrfBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDgetrfBatched_bufferSize(musolverDnHandle_t handle, const int m, const int n, double *const A[], const int lda, const int batch_count, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• double *const A
• const int lda
• const int batch_count
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetrfBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCgetrfBatched_bufferSize(musolverDnHandle_t handle, const int m, const int n, muComplex *const A[], const int lda, const int batch_count, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muComplex *const A
• const int lda
• const int batch_count
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetrfBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZgetrfBatched_bufferSize(musolverDnHandle_t handle, const int m, const int n, muDoubleComplex *const A[], const int lda, const int batch_count, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muDoubleComplex *const A
• const int lda
• const int batch_count
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgeqrf

musolverStatus_t MUSOLVERAPI musolverDnSgeqrf(musolverDnHandle_t handle, int m, int n, float *A, int lda, float *TAU, float *Workspace, int Lwork, int *devInfo)

GEQRF computes a QR factorization of a general m-by-n matrix A.

(This is the blocked version of the algorithm).

The factorization has the form

formula {"type":"element","name":"formula","attributes":{"id":"28"},"children":[{"type":"text","text":"\\[\n A = Q\\left[\\begin{array}{c}\n R\\\\\n 0\n \\end{array}\\right]\n \\]"}]}

where R is upper triangular (upper trapezoidal if m < n), and Q is a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"29"},"children":[{"type":"text","text":"\\[\n Q = H_1H_2\\cdots H_k, \\quad \\text{with} \\: k = \\text{min}(m,n)\n \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"30"},"children":[{"type":"text","text":"\\[\n H_i = I - \\text{ipiv}[i] \\cdot v_i v_i'\n \\]"}]}

where the first i-1 elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"31"},"children":[{"type":"text","text":"$v_i[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of the matrix A.
• n: int. n >= 0.
  The number of columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the m-by-n matrix to be factored. On exit, the elements on and above the diagonal contain the factor R; the elements below the diagonal are the last m - i elements of Householder vector v_i.
• lda: int. lda >= m.
  Specifies the leading dimension of A.
• ipiv: pointer to type. Array on the GPU of dimension min(m,n).
  The Householder scalars.
• bufferSize: int.
  Specifies the size of buffer.
• devInfo: pointer to int.
  Specifies status of current API.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• float * A
• int lda
• float * TAU
• float * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgeqrf

musolverStatus_t MUSOLVERAPI musolverDnDgeqrf(musolverDnHandle_t handle, int m, int n, double *A, int lda, double *TAU, double *Workspace, int Lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• double * A
• int lda
• double * TAU
• double * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgeqrf

musolverStatus_t MUSOLVERAPI musolverDnCgeqrf(musolverDnHandle_t handle, int m, int n, muComplex *A, int lda, muComplex *TAU, muComplex *Workspace, int Lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muComplex * A
• int lda
• muComplex * TAU
• muComplex * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgeqrf

musolverStatus_t MUSOLVERAPI musolverDnZgeqrf(musolverDnHandle_t handle, int m, int n, muDoubleComplex *A, int lda, muDoubleComplex *TAU, muDoubleComplex *Workspace, int Lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muDoubleComplex * A
• int lda
• muDoubleComplex * TAU
• muDoubleComplex * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgeqrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSgeqrf_bufferSize(musolverDnHandle_t handle, int m, int n, float *A, int lda, int *lwork)

get buffer size to compute QR factorization.

{@

This function computes the required workspace size for GEQRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• float * A
• int lda
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgeqrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDgeqrf_bufferSize(musolverDnHandle_t handle, int m, int n, double *A, int lda, int *lwork)

get buffer size to compute QR factorization.

{@

This function computes the required workspace size for GEQRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• double * A
• int lda
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgeqrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCgeqrf_bufferSize(musolverDnHandle_t handle, int m, int n, muComplex *A, int lda, int *lwork)

get buffer size to compute QR factorization.

{@

This function computes the required workspace size for GEQRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muComplex * A
• int lda
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgeqrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZgeqrf_bufferSize(musolverDnHandle_t handle, int m, int n, muDoubleComplex *A, int lda, int *lwork)

get buffer size to compute QR factorization.

{@

This function computes the required workspace size for GEQRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• muDoubleComplex * A
• int lda
• int * lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgeqrfBatched

musolverStatus_t MUSOLVERAPI musolverDnSgeqrfBatched(musolverDnHandle_t handle, const int m, const int n, float *const A[], const int lda, float *ipiv, const int strideP, const int batch_count)

GEQRF_BATCHED computes the QR factorization of a batch of general m-by-n matrices.

(This is the blocked version of the algorithm).

The factorization of matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} in the batch has the form

formula {"type":"element","name":"formula","attributes":{"id":"32"},"children":[{"type":"text","text":"\\[\n A_j = Q_j\\left[\\begin{array}{c}\n R_j\\\\\n 0\n \\end{array}\\right]\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"33"},"children":[{"type":"text","text":"$R_j$"}]} is upper triangular (upper trapezoidal if m < n), and formula {"type":"element","name":"formula","attributes":{"id":"34"},"children":[{"type":"text","text":"$Q_j$"}]} is a m-by-m orthogonal/unitary matrix represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"35"},"children":[{"type":"text","text":"\\[\n Q_j = H_{j_1}H_{j_2}\\cdots H_{j_k}, \\quad \\text{with} \\: k =\n\\text{min}(m,n) \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"36"},"children":[{"type":"text","text":"$H_{j_i}$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"37"},"children":[{"type":"text","text":"\\[\n H_{j_i} = I - \\text{ipiv}_j[i] \\cdot v_{j_i} v_{j_i}'\n \\]"}]}

where the first i-1 elements of Householder vector formula {"type":"element","name":"formula","attributes":{"id":"38"},"children":[{"type":"text","text":"$v_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"39"},"children":[{"type":"text","text":"$v_{j_i}[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of all the matrices A_j in the batch.
• n: int. n >= 0.
  The number of columns of all the matrices A_j in the batch.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the m-by-n matrices A_j to be factored. On exit, the elements on and above the diagonal contain the factor R_j. The elements below the diagonal are the last m - i elements of Householder vector v_(j_i).
• lda: int. lda >= m.
  Specifies the leading dimension of matrices A_j.
• ipiv: pointer to type. Array on the GPU (the size depends on the value of strideP).
  Contains the vectors ipiv_j of corresponding Householder scalars.
• strideP: int.
  Stride from the start of one vector ipiv_j to the next one ipiv_(j+1). There is no restriction for the value of strideP. Normal use is strideP >= min(m,n).
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• float *const A
• const int lda
• float * ipiv
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgeqrfBatched

musolverStatus_t MUSOLVERAPI musolverDnDgeqrfBatched(musolverDnHandle_t handle, const int m, const int n, double *const A[], const int lda, double *ipiv, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• double *const A
• const int lda
• double * ipiv
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgeqrfBatched

musolverStatus_t MUSOLVERAPI musolverDnCgeqrfBatched(musolverDnHandle_t handle, const int m, const int n, muComplex *const A[], const int lda, muComplex *ipiv, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muComplex *const A
• const int lda
• muComplex * ipiv
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgeqrfBatched

musolverStatus_t MUSOLVERAPI musolverDnZgeqrfBatched(musolverDnHandle_t handle, const int m, const int n, muDoubleComplex *const A[], const int lda, muDoubleComplex *ipiv, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muDoubleComplex *const A
• const int lda
• muDoubleComplex * ipiv
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgebrd

musolverStatus_t MUSOLVERAPI musolverDnSgebrd(musolverDnHandle_t handle, const int m, const int n, float *A, const int lda, float *D, float *E, float *tauq, float *taup)

GEBRD computes the bidiagonal form of a general m-by-n matrix A.

(This is the blocked version of the algorithm).

The bidiagonal form is given by:

formula {"type":"element","name":"formula","attributes":{"id":"40"},"children":[{"type":"text","text":"\\[\n B = Q' A P\n \\]"}]}

where B is upper bidiagonal if m >= n and lower bidiagonal if m < n, and Q and P are orthogonal/unitary matrices represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"41"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Q = H_1H_2\\cdots H_n\\: \\text{and} \\: P = G_1G_2\\cdots G_{n-1}, & \\:\n\\text{if}\\: m >= n, \\:\\text{or}\\\\ Q = H_1H_2\\cdots H_{m-1}\\: \\text{and} \\: P\n= G_1G_2\\cdots G_{m}, & \\: \\text{if}\\: m < n. \\end{array} \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"42"},"children":[{"type":"text","text":"$G_i$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"43"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n H_i = I - \\text{tauq}[i] \\cdot v_i v_i', & \\: \\text{and}\\\\\n G_i = I - \\text{taup}[i] \\cdot u_i' u_i.\n \\end{array}\n \\]"}]}

If m >= n, the first i-1 elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"31"},"children":[{"type":"text","text":"$v_i[i] = 1$"}]}; while the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"44"},"children":[{"type":"text","text":"$u_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"45"},"children":[{"type":"text","text":"$u_i[i+1] = 1$"}]}. If m < n, the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"46"},"children":[{"type":"text","text":"$v_i[i+1] =\n1$"}]}; while the first i-1 elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"44"},"children":[{"type":"text","text":"$u_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"47"},"children":[{"type":"text","text":"$u_i[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of the matrix A.
• n: int. n >= 0.
  The number of columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the m-by-n matrix to be factored. On exit, the elements on the diagonal and superdiagonal (if m >= n), or subdiagonal (if m < n) contain the bidiagonal form B. If m >= n, the elements below the diagonal are the last m - i elements of Householder vector v_i, and the elements above the superdiagonal are the last n - i - 1 elements of Householder vector u_i. If m < n, the elements below the subdiagonal are the last m - i - 1 elements of Householder vector v_i, and the elements above the diagonal are the last n - i elements of Householder vector u_i.
• lda: int. lda >= m.
  specifies the leading dimension of A.
• D: pointer to real type. Array on the GPU of dimension min(m,n).
  The diagonal elements of B.
• E: pointer to real type. Array on the GPU of dimension min(m,n)-1.
  The off-diagonal elements of B.
• tauq: pointer to type. Array on the GPU of dimension min(m,n).
  The Householder scalars associated with matrix Q.
• taup: pointer to type. Array on the GPU of dimension min(m,n).
  The Householder scalars associated with matrix P.

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• float * A
• const int lda
• float * D
• float * E
• float * tauq
• float * taup

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgebrd

musolverStatus_t MUSOLVERAPI musolverDnDgebrd(musolverDnHandle_t handle, const int m, const int n, double *A, const int lda, double *D, double *E, double *tauq, double *taup)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• double * A
• const int lda
• double * D
• double * E
• double * tauq
• double * taup

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgebrd

musolverStatus_t MUSOLVERAPI musolverDnCgebrd(musolverDnHandle_t handle, const int m, const int n, muComplex *A, const int lda, float *D, float *E, muComplex *tauq, muComplex *taup)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muComplex * A
• const int lda
• float * D
• float * E
• muComplex * tauq
• muComplex * taup

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgebrd

musolverStatus_t MUSOLVERAPI musolverDnZgebrd(musolverDnHandle_t handle, const int m, const int n, muDoubleComplex *A, const int lda, double *D, double *E, muDoubleComplex *tauq, muDoubleComplex *taup)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muDoubleComplex * A
• const int lda
• double * D
• double * E
• muDoubleComplex * tauq
• muDoubleComplex * taup

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgebrdBatched

musolverStatus_t MUSOLVERAPI musolverDnSgebrdBatched(musolverDnHandle_t handle, const int m, const int n, float *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, float *tauq, const int strideQ, float *taup, const int strideP, const int batch_count)

GEBRD_BATCHED computes the bidiagonal form of a batch of general m-by-n matrices.

(This is the blocked version of the algorithm).

For each instance in the batch, the bidiagonal form is given by:

formula {"type":"element","name":"formula","attributes":{"id":"48"},"children":[{"type":"text","text":"\\[\n B_j = Q_j' A_j P_j\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"49"},"children":[{"type":"text","text":"$B_j$"}]} is upper bidiagonal if m >= n and lower bidiagonal if m < n, and formula {"type":"element","name":"formula","attributes":{"id":"34"},"children":[{"type":"text","text":"$Q_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"25"},"children":[{"type":"text","text":"$P_j$"}]} are orthogonal/unitary matrices represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"50"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Q_j = H_{j_1}H_{j_2}\\cdots H_{j_n}\\: \\text{and} \\: P_j =\nG_{j_1}G_{j_2}\\cdots G_{j_{n-1}}, & \\: \\text{if}\\: m >= n, \\:\\text{or}\\\\ Q_j\n= H_{j_1}H_{j_2}\\cdots H_{j_{m-1}}\\: \\text{and} \\: P_j =\nG_{j_1}G_{j_2}\\cdots G_{j_m}, & \\: \\text{if}\\: m < n. \\end{array} \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"36"},"children":[{"type":"text","text":"$H_{j_i}$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"51"},"children":[{"type":"text","text":"$G_{j_i}$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"52"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n H_{j_i} = I - \\text{tauq}_j[i] \\cdot v_{j_i} v_{j_i}', & \\: \\text{and}\\\\\n G_{j_i} = I - \\text{taup}_j[i] \\cdot u_{j_i}' u_{j_i}.\n \\end{array}\n \\]"}]}

If m >= n, the first i-1 elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"38"},"children":[{"type":"text","text":"$v_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"39"},"children":[{"type":"text","text":"$v_{j_i}[i] = 1$"}]}; while the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"53"},"children":[{"type":"text","text":"$u_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"54"},"children":[{"type":"text","text":"$u_{j_i}[i+1] = 1$"}]}. If m < n, the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"38"},"children":[{"type":"text","text":"$v_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"55"},"children":[{"type":"text","text":"$v_{j_i}[i+1] = 1$"}]}; while the first i-1 elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"53"},"children":[{"type":"text","text":"$u_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"56"},"children":[{"type":"text","text":"$u_{j_i}[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• m: int. m >= 0.
  The number of rows of all the matrices A_j in the batch.
• n: int. n >= 0.
  The number of columns of all the matrices A_j in the batch.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the m-by-n matrices A_j to be factored. On exit, the elements on the diagonal and superdiagonal (if m >= n), or subdiagonal (if m < n) contain the bidiagonal form B_j. If m >= n, the elements below the diagonal are the last m - i elements of Householder vector v_(j_i), and the elements above the superdiagonal are the last n - i - 1 elements of Householder vector u_(j_i). If m < n, the elements below the subdiagonal are the last m - i - 1 elements of Householder vector v_(j_i), and the elements above the diagonal are the last n - i elements of Householder vector u_(j_i).
• lda: int. lda >= m.
  Specifies the leading dimension of matrices A_j.
• D: pointer to real type. Array on the GPU (the size depends on the value of strideD).
  The diagonal elements of B_j.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use case is strideD >= min(m,n).
• E: pointer to real type. Array on the GPU (the size depends on the value of strideE).
  The off-diagonal elements of B_j.
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= min(m,n)-1.
• tauq: pointer to type. Array on the GPU (the size depends on the value of strideQ).
  Contains the vectors tauq_j of Householder scalars associated with matrices Q_j.
• strideQ: int.
  Stride from the start of one vector tauq_j to the next one tauq_(j+1). There is no restriction for the value of strideQ. Normal use is strideQ >= min(m,n).
• taup: pointer to type. Array on the GPU (the size depends on the value of strideP).
  Contains the vectors taup_j of Householder scalars associated with matrices P_j.
• strideP: int.
  Stride from the start of one vector taup_j to the next one taup_(j+1). There is no restriction for the value of strideP. Normal use is strideP >= min(m,n).
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• float *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• float * tauq
• const int strideQ
• float * taup
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgebrdBatched

musolverStatus_t MUSOLVERAPI musolverDnDgebrdBatched(musolverDnHandle_t handle, const int m, const int n, double *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, double *tauq, const int strideQ, double *taup, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• double *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• double * tauq
• const int strideQ
• double * taup
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgebrdBatched

musolverStatus_t MUSOLVERAPI musolverDnCgebrdBatched(musolverDnHandle_t handle, const int m, const int n, muComplex *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, muComplex *tauq, const int strideQ, muComplex *taup, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muComplex *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• muComplex * tauq
• const int strideQ
• muComplex * taup
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgebrdBatched

musolverStatus_t MUSOLVERAPI musolverDnZgebrdBatched(musolverDnHandle_t handle, const int m, const int n, muDoubleComplex *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, muDoubleComplex *tauq, const int strideQ, muDoubleComplex *taup, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int m
• const int n
• muDoubleComplex *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• muDoubleComplex * tauq
• const int strideQ
• muDoubleComplex * taup
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetrs

musolverStatus_t MUSOLVERAPI musolverDnSgetrs(musolverDnHandle_t handle, mublasOperation_t trans, int n, int nrhs, const float *A, int lda, const int *devIpiv, float *B, int ldb, int *devInfo)

GETRS solves a system of n linear equations on n variables in its factorized form.

It solves one of the following systems, depending on the value of trans:

formula {"type":"element","name":"formula","attributes":{"id":"57"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = B & \\: \\text{not transposed,}\\\\\n A^T X = B & \\: \\text{transposed, or}\\\\\n A^H X = B & \\: \\text{conjugate transposed.}\n \\end{array}\n \\]"}]}

Matrix A is defined by its triangular factors as returned by GETRF.

Parameters:

• handle: musolverDnHandle_t .
• trans: mublasOperation_t.
  Specifies the form of the system of equations.
• n: int. n >= 0.
  The order of the system, i.e. the number of columns and rows of A.
• nrhs: int. nrhs >= 0.
  The number of right hand sides, i.e., the number of columns of the matrix B.
• A: pointer to type. Array on the GPU of dimension ldan.
  The factors L and U of the factorization A = PL*U returned by GETRF.
• lda: int. lda >= n.
  The leading dimension of A.
• ipiv: pointer to int. Array on the GPU of dimension n.
  The pivot indices returned by GETRF.
• B: pointer to type. Array on the GPU of dimension ldb*nrhs.
  On entry, the right hand side matrix B. On exit, the solution matrix X.
• ldb: int. ldb >= n.
  The leading dimension of B.

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• int n
• int nrhs
• const float * A
• int lda
• const int * devIpiv
• float * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetrs

musolverStatus_t MUSOLVERAPI musolverDnDgetrs(musolverDnHandle_t handle, mublasOperation_t trans, int n, int nrhs, const double *A, int lda, const int *devIpiv, double *B, int ldb, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• int n
• int nrhs
• const double * A
• int lda
• const int * devIpiv
• double * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetrs

musolverStatus_t MUSOLVERAPI musolverDnCgetrs(musolverDnHandle_t handle, mublasOperation_t trans, int n, int nrhs, const muComplex *A, int lda, const int *devIpiv, muComplex *B, int ldb, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• int n
• int nrhs
• const muComplex * A
• int lda
• const int * devIpiv
• muComplex * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetrs

musolverStatus_t MUSOLVERAPI musolverDnZgetrs(musolverDnHandle_t handle, mublasOperation_t trans, int n, int nrhs, const muDoubleComplex *A, int lda, const int *devIpiv, muDoubleComplex *B, int ldb, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• int n
• int nrhs
• const muDoubleComplex * A
• int lda
• const int * devIpiv
• muDoubleComplex * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetrsBatched

musolverStatus_t MUSOLVERAPI musolverDnSgetrsBatched(musolverDnHandle_t handle, const mublasOperation_t trans, const int n, const int nrhs, float *const A[], const int lda, const int *ipiv, const int strideP, float *const B[], const int ldb, const int batch_count, int *devInfo)

GETRS_BATCHED solves a batch of systems of n linear equations on n variables in its factorized forms.

For each instance j in the batch, it solves one of the following systems, depending on the value of trans:

formula {"type":"element","name":"formula","attributes":{"id":"58"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = B_j & \\: \\text{not transposed,}\\\\\n A_j^T X_j = B_j & \\: \\text{transposed, or}\\\\\n A_j^H X_j = B_j & \\: \\text{conjugate transposed.}\n \\end{array}\n \\]"}]}

Matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is defined by its triangular factors as returned by GETRF_BATCHED.

Parameters:

• handle: musolverDnHandle_t .
• trans: mublasOperation_t.
  Specifies the form of the system of equations of each instance in the batch.
• n: int. n >= 0.
  The order of the system, i.e. the number of columns and rows of all A_j matrices.
• nrhs: int. nrhs >= 0.
  The number of right hand sides, i.e., the number of columns of all the matrices B_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldan.
  The factors L_j and U_j of the factorization A_j = P_jL_j*U_j returned by GETRF_BATCHED.
• lda: int. lda >= n.
  The leading dimension of matrices A_j.
• ipiv: pointer to int. Array on the GPU (the size depends on the value of strideP).
  Contains the vectors ipiv_j of pivot indices returned by GETRF_BATCHED.
• strideP: int.
  Stride from the start of one vector ipiv_j to the next one ipiv_(j+1). There is no restriction for the value of strideP. Normal use case is strideP >= n.
• B: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.
  On entry, the right hand side matrices B_j. On exit, the solution matrix X_j of each system in the batch.
• ldb: int. ldb >= n.
  The leading dimension of matrices B_j.
• batch_count: int. batch_count >= 0.
  Number of instances (systems) in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasOperation_t trans
• const int n
• const int nrhs
• float *const A
• const int lda
• const int * ipiv
• const int strideP
• float *const B
• const int ldb
• const int batch_count
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetrsBatched

musolverStatus_t MUSOLVERAPI musolverDnDgetrsBatched(musolverDnHandle_t handle, const mublasOperation_t trans, const int n, const int nrhs, double *const A[], const int lda, const int *ipiv, const int strideP, double *const B[], const int ldb, const int batch_count, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• const mublasOperation_t trans
• const int n
• const int nrhs
• double *const A
• const int lda
• const int * ipiv
• const int strideP
• double *const B
• const int ldb
• const int batch_count
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetrsBatched

musolverStatus_t MUSOLVERAPI musolverDnCgetrsBatched(musolverDnHandle_t handle, const mublasOperation_t trans, const int n, const int nrhs, muComplex *const A[], const int lda, const int *ipiv, const int strideP, muComplex *const B[], const int ldb, const int batch_count, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• const mublasOperation_t trans
• const int n
• const int nrhs
• muComplex *const A
• const int lda
• const int * ipiv
• const int strideP
• muComplex *const B
• const int ldb
• const int batch_count
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetrsBatched

musolverStatus_t MUSOLVERAPI musolverDnZgetrsBatched(musolverDnHandle_t handle, const mublasOperation_t trans, const int n, const int nrhs, muDoubleComplex *const A[], const int lda, const int *ipiv, const int strideP, muDoubleComplex *const B[], const int ldb, const int batch_count, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• const mublasOperation_t trans
• const int n
• const int nrhs
• muDoubleComplex *const A
• const int lda
• const int * ipiv
• const int strideP
• muDoubleComplex *const B
• const int ldb
• const int batch_count
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesv

musolverStatus_t MUSOLVERAPI musolverDnSgesv(musolverDnHandle_t handle, const int n, const int nrhs, float *A, const int lda, int *ipiv, float *B, const int ldb, int *info)

GESV solves a general system of n linear equations on n variables.

The linear system is of the form

formula {"type":"element","name":"formula","attributes":{"id":"59"},"children":[{"type":"text","text":"\\[\n A X = B\n \\]"}]}

where A is a general n-by-n matrix. Matrix A is first factorized in triangular factors L and U using GETRF; then, the solution is computed with GETRS.

Parameters:

• handle: musolverDnHandle_t .
• n: int. n >= 0.
  The order of the system, i.e. the number of columns and rows of A.
• nrhs: int. nrhs >= 0.
  The number of right hand sides, i.e., the number of columns of the matrix B.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, if info = 0, the factors L and U of the LU decomposition of A returned by GETRF.
• lda: int. lda >= n.
  The leading dimension of A.
• ipiv: pointer to int. Array on the GPU of dimension n.
  The pivot indices returned by GETRF.
• B: pointer to type. Array on the GPU of dimension ldb*nrhs.
  On entry, the right hand side matrix B. On exit, the solution matrix X.
• ldb: int. ldb >= n.
  The leading dimension of B.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, U is singular, and the solution could not be computed. U[i,i] is the first zero element in the diagonal.

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• float * A
• const int lda
• int * ipiv
• float * B
• const int ldb
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesv

musolverStatus_t MUSOLVERAPI musolverDnDgesv(musolverDnHandle_t handle, const int n, const int nrhs, double *A, const int lda, int *ipiv, double *B, const int ldb, int *info)

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• double * A
• const int lda
• int * ipiv
• double * B
• const int ldb
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesv

musolverStatus_t MUSOLVERAPI musolverDnCgesv(musolverDnHandle_t handle, const int n, const int nrhs, muComplex *A, const int lda, int *ipiv, muComplex *B, const int ldb, int *info)

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• muComplex * A
• const int lda
• int * ipiv
• muComplex * B
• const int ldb
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesv

musolverStatus_t MUSOLVERAPI musolverDnZgesv(musolverDnHandle_t handle, const int n, const int nrhs, muDoubleComplex *A, const int lda, int *ipiv, muDoubleComplex *B, const int ldb, int *info)

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• muDoubleComplex * A
• const int lda
• int * ipiv
• muDoubleComplex * B
• const int ldb
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvBatched

musolverStatus_t MUSOLVERAPI musolverDnSgesvBatched(musolverDnHandle_t handle, const int n, const int nrhs, float *const A[], const int lda, int *ipiv, const int strideP, float *const B[], const int ldb, int *info, const int batch_count)

GESV_BATCHED solves a batch of general systems of n linear equations on n variables.

The linear systems are of the form

formula {"type":"element","name":"formula","attributes":{"id":"60"},"children":[{"type":"text","text":"\\[\n A_j X_j = B_j\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is a general n-by-n matrix. Matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is first factorized in triangular factors formula {"type":"element","name":"formula","attributes":{"id":"26"},"children":[{"type":"text","text":"$L_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} using GETRF_BATCHED; then, the solutions are computed with GETRS_BATCHED.

Parameters:

• handle: musolverDnHandle_t .
• n: int. n >= 0.
  The order of the system, i.e. the number of columns and rows of all A_j matrices.
• nrhs: int. nrhs >= 0.
  The number of right hand sides, i.e., the number of columns of all the matrices B_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, if info_j = 0, the factors L_j and U_j of the LU decomposition of A_j returned by GETRF_BATCHED.
• lda: int. lda >= n.
  The leading dimension of matrices A_j.
• ipiv: pointer to int. Array on the GPU (the size depends on the value of strideP).
  The vectors ipiv_j of pivot indices returned by GETRF_BATCHED.
• strideP: int.
  Stride from the start of one vector ipiv_j to the next one ipiv_(j+1). There is no restriction for the value of strideP. Normal use case is strideP >= n.
• B: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.
  On entry, the right hand side matrices B_j. On exit, the solution matrix X_j of each system in the batch.
• ldb: int. ldb >= n.
  The leading dimension of matrices B_j.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for A_j. If info[i] = j > 0, U_i is singular, and the solution could not be computed. U_j[i,i] is the first zero element in the diagonal.
• batch_count: int. batch_count >= 0.
  Number of instances (systems) in the batch.

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• float *const A
• const int lda
• int * ipiv
• const int strideP
• float *const B
• const int ldb
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvBatched

musolverStatus_t MUSOLVERAPI musolverDnDgesvBatched(musolverDnHandle_t handle, const int n, const int nrhs, double *const A[], const int lda, int *ipiv, const int strideP, double *const B[], const int ldb, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• double *const A
• const int lda
• int * ipiv
• const int strideP
• double *const B
• const int ldb
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvBatched

musolverStatus_t MUSOLVERAPI musolverDnCgesvBatched(musolverDnHandle_t handle, const int n, const int nrhs, muComplex *const A[], const int lda, int *ipiv, const int strideP, muComplex *const B[], const int ldb, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• muComplex *const A
• const int lda
• int * ipiv
• const int strideP
• muComplex *const B
• const int ldb
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvBatched

musolverStatus_t MUSOLVERAPI musolverDnZgesvBatched(musolverDnHandle_t handle, const int n, const int nrhs, muDoubleComplex *const A[], const int lda, int *ipiv, const int strideP, muDoubleComplex *const B[], const int ldb, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int n
• const int nrhs
• muDoubleComplex *const A
• const int lda
• int * ipiv
• const int strideP
• muDoubleComplex *const B
• const int ldb
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetri

musolverStatus_t MUSOLVERAPI musolverDnSgetri(musolverDnHandle_t handle, const int n, float *A, const int lda, int *ipiv, int *info)

GETRI inverts a general n-by-n matrix A using the LU factorization computed by GETRF.

The inverse is computed by solving the linear system

formula {"type":"element","name":"formula","attributes":{"id":"61"},"children":[{"type":"text","text":"\\[\n A^{-1}L = U^{-1}\n \\]"}]}

where L is the lower triangular factor of A with unit diagonal elements, and U is the upper triangular factor.

Parameters:

• handle: musolverDnHandle_t .
• n: int. n >= 0.
  The number of rows and columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension ldan.
  On entry, the factors L and U of the factorization A = PL*U returned by GETRF. On exit, the inverse of A if info = 0; otherwise undefined.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• ipiv: pointer to int. Array on the GPU of dimension n.
  The pivot indices returned by GETRF.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, U is singular. U[i,i] is the first zero pivot.

Parameters:

• musolverDnHandle_t handle
• const int n
• float * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetri

musolverStatus_t MUSOLVERAPI musolverDnDgetri(musolverDnHandle_t handle, const int n, double *A, const int lda, int *ipiv, int *info)

Parameters:

• musolverDnHandle_t handle
• const int n
• double * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetri

musolverStatus_t MUSOLVERAPI musolverDnCgetri(musolverDnHandle_t handle, const int n, muComplex *A, const int lda, int *ipiv, int *info)

Parameters:

• musolverDnHandle_t handle
• const int n
• muComplex * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetri

musolverStatus_t MUSOLVERAPI musolverDnZgetri(musolverDnHandle_t handle, const int n, muDoubleComplex *A, const int lda, int *ipiv, int *info)

Parameters:

• musolverDnHandle_t handle
• const int n
• muDoubleComplex * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgetriBatched

musolverStatus_t MUSOLVERAPI musolverDnSgetriBatched(musolverDnHandle_t handle, const int n, float *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

GETRI_BATCHED inverts a batch of general n-by-n matrices using the LU factorization computed by GETRF_BATCHED.

The inverse of matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} in the batch is computed by solving the linear system

formula {"type":"element","name":"formula","attributes":{"id":"62"},"children":[{"type":"text","text":"\\[\n A_j^{-1} L_j = U_j^{-1}\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"26"},"children":[{"type":"text","text":"$L_j$"}]} is the lower triangular factor of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} with unit diagonal elements, and formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} is the upper triangular factor.

Parameters:

• handle: musolverDnHandle_t .
• n: int. n >= 0.
  The number of rows and columns of all matrices A_j in the batch.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension ldan.
  On entry, the factors L_j and U_j of the factorization A = P_jL_j*U_j returned by GETRF_BATCHED. On exit, the inverses of A_j if info[j] = 0; otherwise undefined.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• ipiv: pointer to int. Array on the GPU (the size depends on the value of strideP).
  The pivot indices returned by GETRF_BATCHED.
• strideP: int.
  Stride from the start of one vector ipiv_j to the next one ipiv_(i+j). There is no restriction for the value of strideP. Normal use case is strideP >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for inversion of A_j. If info[j] = i > 0, U_j is singular. U_j[i,i] is the first zero pivot.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const int n
• float *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgetriBatched

musolverStatus_t MUSOLVERAPI musolverDnDgetriBatched(musolverDnHandle_t handle, const int n, double *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int n
• double *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgetriBatched

musolverStatus_t MUSOLVERAPI musolverDnCgetriBatched(musolverDnHandle_t handle, const int n, muComplex *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int n
• muComplex *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgetriBatched

musolverStatus_t MUSOLVERAPI musolverDnZgetriBatched(musolverDnHandle_t handle, const int n, muDoubleComplex *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const int n
• muDoubleComplex *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgels

musolverStatus_t MUSOLVERAPI musolverDnSgels(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, float *A, const int lda, float *B, const int ldb, int *info, void *buffer)

GELS solves an overdetermined (or underdetermined) linear system defined by an m-by-n matrix A, and a corresponding matrix B, using the QR factorization computed by GEQRF (or the LQ factorization computed by GELQF).

Depending on the value of trans, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"63"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = B & \\: \\text{not transposed, or}\\\\\n A' X = B & \\: \\text{transposed if real, or conjugate transposed if\ncomplex} \\end{array} \\]"}]}

If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined and a least-squares solution approximating X is found by minimizing

formula {"type":"element","name":"formula","attributes":{"id":"64"},"children":[{"type":"text","text":"\\[\n || B - A X || \\quad \\text{(or} \\: || B - A' X ||\\text{)}\n \\]"}]}

If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined and a unique solution for X is chosen such that formula {"type":"element","name":"formula","attributes":{"id":"65"},"children":[{"type":"text","text":"$|| X ||$"}]} is minimal.

Parameters:

• handle: musolverDnHandle_t .
• trans: mublasOperation_t.
  Specifies the form of the system of equations.
• m: int. m >= 0.
  The number of rows of matrix A.
• n: int. n >= 0.
  The number of columns of matrix A.
• nrhs: int. nrhs >= 0.
  The number of columns of matrices B and X; i.e., the columns on the right hand side.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the QR (or LQ) factorization of A as returned by GEQRF (or GELQF).
• lda: int. lda >= m.
  Specifies the leading dimension of matrix A.
• B: pointer to type. Array on the GPU of dimension ldb*nrhs.
  On entry, the matrix B. On exit, when info = 0, B is overwritten by the solution vectors (and the residuals in the overdetermined cases) stored as columns.
• ldb: int. ldb >= max(m,n).
  Specifies the leading dimension of matrix B.
• info: pointer to int on the GPU.
  If info = 0, successful exit. If info = i > 0, the solution could not be computed because input matrix A is rank deficient; the i-th diagonal element of its triangular factor is zero.

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• float * A
• const int lda
• float * B
• const int ldb
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgels

musolverStatus_t MUSOLVERAPI musolverDnDgels(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, double *A, const int lda, double *B, const int ldb, int *info, void *buffer)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• double * A
• const int lda
• double * B
• const int ldb
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgels

musolverStatus_t MUSOLVERAPI musolverDnCgels(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, muComplex *A, const int lda, muComplex *B, const int ldb, int *info, void *buffer)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• muComplex * A
• const int lda
• muComplex * B
• const int ldb
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgels

musolverStatus_t MUSOLVERAPI musolverDnZgels(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, muDoubleComplex *A, const int lda, muDoubleComplex *B, const int ldb, int *info, void *buffer)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• muDoubleComplex * A
• const int lda
• muDoubleComplex * B
• const int ldb
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgels_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSgels_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgels_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDgels_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgels_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCgels_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgels_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZgels_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgelsBatched

musolverStatus_t MUSOLVERAPI musolverDnSgelsBatched(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, float *const A[], const int lda, float *const B[], const int ldb, int *info, const int batch_count, void *buffer)

GELS_BATCHED solves a batch of overdetermined (or underdetermined) linear systems defined by a set of m-by-n matrices formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}, and corresponding matrices formula {"type":"element","name":"formula","attributes":{"id":"49"},"children":[{"type":"text","text":"$B_j$"}]}, using the QR factorizations computed by GEQRF_BATCHED (or the LQ factorizations computed by GELQF_BATCHED).

For each instance in the batch, depending on the value of trans, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"66"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = B_j & \\: \\text{not transposed, or}\\\\\n A_j' X_j = B_j & \\: \\text{transposed if real, or conjugate transposed if\ncomplex} \\end{array} \\]"}]}

If m >= n (or m < n in the case of transpose/conjugate transpose), the system is overdetermined and a least-squares solution approximating X_j is found by minimizing

formula {"type":"element","name":"formula","attributes":{"id":"67"},"children":[{"type":"text","text":"\\[\n || B_j - A_j X_j || \\quad \\text{(or} \\: || B_j - A_j' X_j ||\\text{)}\n \\]"}]}

If m < n (or m >= n in the case of transpose/conjugate transpose), the system is underdetermined and a unique solution for X_j is chosen such that formula {"type":"element","name":"formula","attributes":{"id":"68"},"children":[{"type":"text","text":"$|| X_j ||$"}]} is minimal.

Parameters:

• handle: musolverDnHandle_t .
• trans: mublasOperation_t.
  Specifies the form of the system of equations.
• m: int. m >= 0.
  The number of rows of all matrices A_j in the batch.
• n: int. n >= 0.
  The number of columns of all matrices A_j in the batch.
• nrhs: int. nrhs >= 0.
  The number of columns of all matrices B_j and X_j in the batch; i.e., the columns on the right hand side.
• A: array of pointer to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the QR (or LQ) factorizations of A_j as returned by GEQRF_BATCHED (or GELQF_BATCHED).
• lda: int. lda >= m.
  Specifies the leading dimension of matrices A_j.
• B: array of pointer to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.
  On entry, the matrices B_j. On exit, when info[j] = 0, B_j is overwritten by the solution vectors (and the residuals in the overdetermined cases) stored as columns.
• ldb: int. ldb >= max(m,n).
  Specifies the leading dimension of matrices B_j.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for solution of A_j. If info[j] = i > 0, the solution of A_j could not be computed because input matrix A_j is rank deficient; the i-th diagonal element of its triangular factor is zero.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• float *const A
• const int lda
• float *const B
• const int ldb
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgelsBatched

musolverStatus_t MUSOLVERAPI musolverDnDgelsBatched(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, double *const A[], const int lda, double *const B[], const int ldb, int *info, const int batch_count, void *buffer)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• double *const A
• const int lda
• double *const B
• const int ldb
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgelsBatched

musolverStatus_t MUSOLVERAPI musolverDnCgelsBatched(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, muComplex *const A[], const int lda, muComplex *const B[], const int ldb, int *info, const int batch_count, void *buffer)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• muComplex *const A
• const int lda
• muComplex *const B
• const int ldb
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgelsBatched

musolverStatus_t MUSOLVERAPI musolverDnZgelsBatched(musolverDnHandle_t handle, mublasOperation_t trans, const int m, const int n, const int nrhs, muDoubleComplex *const A[], const int lda, muDoubleComplex *const B[], const int ldb, int *info, const int batch_count, void *buffer)

Parameters:

• musolverDnHandle_t handle
• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• muDoubleComplex *const A
• const int lda
• muDoubleComplex *const B
• const int ldb
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgelsBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSgelsBatched_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, const int batch_count, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgelsBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDgelsBatched_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, const int batch_count, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgelsBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCgelsBatched_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, const int batch_count, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgelsBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZgelsBatched_bufferSize(mublasOperation_t trans, const int m, const int n, const int nrhs, const int batch_count, size_t *buffersize)

Parameters:

• mublasOperation_t trans
• const int m
• const int n
• const int nrhs
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSpotrf

musolverStatus_t MUSOLVERAPI musolverDnSpotrf(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, float *A, int lda, float *Workspace, int Lwork, int *devInfo)

POTRF computes the Cholesky factorization of a real symmetric (complex Hermitian) positive definite matrix A.

(This is the blocked version of the algorithm).

The factorization has the form:

formula {"type":"element","name":"formula","attributes":{"id":"69"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A = U'U & \\: \\text{if uplo is upper, or}\\\\\n A = LL' & \\: \\text{if uplo is lower.}\n \\end{array}\n \\]"}]}

U is an upper triangular matrix and L is lower triangular.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the factorization is upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A to be factored. On exit, the lower or upper triangular factor.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• info: pointer to a int on the GPU.
  If info = 0, successful factorization of matrix A. If info = i > 0, the leading minor of order i of A is not positive definite. The factorization stopped at this point.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• float * A
• int lda
• float * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDpotrf

musolverStatus_t MUSOLVERAPI musolverDnDpotrf(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, double *A, int lda, double *Workspace, int Lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• double * A
• int lda
• double * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCpotrf

musolverStatus_t MUSOLVERAPI musolverDnCpotrf(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, muComplex *A, int lda, muComplex *Workspace, int Lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• muComplex * A
• int lda
• muComplex * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZpotrf

musolverStatus_t MUSOLVERAPI musolverDnZpotrf(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, muDoubleComplex *A, int lda, muDoubleComplex *Workspace, int Lwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• muDoubleComplex * A
• int lda
• muDoubleComplex * Workspace
• int Lwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSpotrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSpotrf_bufferSize(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, float *A, int lda, int *Lwork)

get buffer size to compute Cholesky factorization.

{@

This function computes the required workspace size for POTRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• float * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDpotrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDpotrf_bufferSize(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, double *A, int lda, int *Lwork)

get buffer size to compute Cholesky factorization.

{@

This function computes the required workspace size for POTRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• double * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCpotrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCpotrf_bufferSize(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, muComplex *A, int lda, int *Lwork)

get buffer size to compute Cholesky factorization.

{@

This function computes the required workspace size for POTRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• muComplex * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZpotrf_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZpotrf_bufferSize(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, muDoubleComplex *A, int lda, int *Lwork)

get buffer size to compute Cholesky factorization.

{@

This function computes the required workspace size for POTRF operation.

Parameters:

• handle: musolverDnHandle_t.
• m: int. The number of rows of the matrix A.
• n: int. The number of columns of the matrix A.
• A: pointer to type. Array on the GPU containing the matrix A.
• lda: int. The leading dimension of A.
• lwork: pointer to int. Returns the required workspace size.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• muDoubleComplex * A
• int lda
• int * Lwork

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSpotrfBatched

musolverStatus_t MUSOLVERAPI musolverDnSpotrfBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, float *Aarray[], int lda, int *infoArray, int batchSize)

POTRF_BATCHED computes the Cholesky factorization of a batch of real symmetric (complex Hermitian) positive definite matrices.

(This is the blocked version of the algorithm).

The factorization of matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} in the batch has the form:

formula {"type":"element","name":"formula","attributes":{"id":"70"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j = U_j'U_j & \\: \\text{if uplo is upper, or}\\\\\n A_j = L_jL_j' & \\: \\text{if uplo is lower.}\n \\end{array}\n \\]"}]}

formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} is an upper triangular matrix and formula {"type":"element","name":"formula","attributes":{"id":"26"},"children":[{"type":"text","text":"$L_j$"}]} is lower triangular.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the factorization is upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of matrix A_j.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j to be factored. On exit, the upper or lower triangular factors.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful factorization of matrix A_j. If info[j] = i > 0, the leading minor of order i of A_j is not positive definite. The j-th factorization stopped at this point.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• float * Aarray
• int lda
• int * infoArray
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDpotrfBatched

musolverStatus_t MUSOLVERAPI musolverDnDpotrfBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, double *Aarray[], int lda, int *infoArray, int batchSize)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• double * Aarray
• int lda
• int * infoArray
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCpotrfBatched

musolverStatus_t MUSOLVERAPI musolverDnCpotrfBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, muComplex *Aarray[], int lda, int *infoArray, int batchSize)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• muComplex * Aarray
• int lda
• int * infoArray
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZpotrfBatched

musolverStatus_t MUSOLVERAPI musolverDnZpotrfBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, muDoubleComplex *Aarray[], int lda, int *infoArray, int batchSize)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• muDoubleComplex * Aarray
• int lda
• int * infoArray
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSpotrs

musolverStatus_t MUSOLVERAPI musolverDnSpotrs(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, float *A, int lda, float *B, int ldb, int *devInfo)

POTRS solves a symmetric/hermitian system of n linear equations on n variables in its factorized form.

It solves the system

formula {"type":"element","name":"formula","attributes":{"id":"59"},"children":[{"type":"text","text":"\\[\n A X = B\n \\]"}]}

where A is a real symmetric (complex hermitian) positive definite matrix defined by its triangular factor

formula {"type":"element","name":"formula","attributes":{"id":"69"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A = U'U & \\: \\text{if uplo is upper, or}\\\\\n A = LL' & \\: \\text{if uplo is lower.}\n \\end{array}\n \\]"}]}

as returned by POTRF.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the factorization is upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The order of the system, i.e. the number of columns and rows of A.
• nrhs: int. nrhs >= 0.
  The number of right hand sides, i.e., the number of columns of the matrix B.
• A: pointer to type. Array on the GPU of dimension lda*n.
  The factor L or U of the Cholesky factorization of A returned by POTRF.
• lda: int. lda >= n.
  The leading dimension of A.
• B: pointer to type. Array on the GPU of dimension ldb*nrhs.
  On entry, the right hand side matrix B. On exit, the solution matrix X.
• ldb: int. ldb >= n.
  The leading dimension of B.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• float * A
• int lda
• float * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDpotrs

musolverStatus_t MUSOLVERAPI musolverDnDpotrs(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, double *A, int lda, double *B, int ldb, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• double * A
• int lda
• double * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCpotrs

musolverStatus_t MUSOLVERAPI musolverDnCpotrs(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, muComplex *A, int lda, muComplex *B, int ldb, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• muComplex * A
• int lda
• muComplex * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZpotrs

musolverStatus_t MUSOLVERAPI musolverDnZpotrs(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, muDoubleComplex *A, int lda, muDoubleComplex *B, int ldb, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• muDoubleComplex * A
• int lda
• muDoubleComplex * B
• int ldb
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSpotrsBatched

musolverStatus_t MUSOLVERAPI musolverDnSpotrsBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, float *A[], int lda, float *B[], int ldb, int *info, int batchSize)

POTRS_BATCHED solves a batch of symmetric/hermitian systems of n linear equations on n variables in its factorized forms.

For each instance j in the batch, it solves the system

formula {"type":"element","name":"formula","attributes":{"id":"60"},"children":[{"type":"text","text":"\\[\n A_j X_j = B_j\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is a real symmetric (complex hermitian) positive definite matrix defined by its triangular factor

formula {"type":"element","name":"formula","attributes":{"id":"70"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j = U_j'U_j & \\: \\text{if uplo is upper, or}\\\\\n A_j = L_jL_j' & \\: \\text{if uplo is lower.}\n \\end{array}\n \\]"}]}

as returned by POTRF_BATCHED.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the factorization is upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The order of the system, i.e. the number of columns and rows of all A_j matrices.
• nrhs: int. nrhs >= 0.
  The number of right hand sides, i.e., the number of columns of all the matrices B_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  The factor L_j or U_j of the Cholesky factorization of A_j returned by POTRF_BATCHED.
• lda: int. lda >= n.
  The leading dimension of matrices A_j.
• B: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*nrhs.
  On entry, the right hand side matrices B_j. On exit, the solution matrix X_j of each system in the batch.
• ldb: int. ldb >= n.
  The leading dimension of matrices B_j.
• batch_count: int. batch_count >= 0.
  Number of instances (systems) in the batch.

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• float * A
• int lda
• float * B
• int ldb
• int * info
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDpotrsBatched

musolverStatus_t MUSOLVERAPI musolverDnDpotrsBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, double *A[], int lda, double *B[], int ldb, int *info, int batchSize)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• double * A
• int lda
• double * B
• int ldb
• int * info
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCpotrsBatched

musolverStatus_t MUSOLVERAPI musolverDnCpotrsBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, muComplex *A[], int lda, muComplex *B[], int ldb, int *info, int batchSize)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• muComplex * A
• int lda
• muComplex * B
• int ldb
• int * info
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZpotrsBatched

musolverStatus_t MUSOLVERAPI musolverDnZpotrsBatched(musolverDnHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, muDoubleComplex *A[], int lda, muDoubleComplex *B[], int ldb, int *info, int batchSize)

Parameters:

• musolverDnHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• muDoubleComplex * A
• int lda
• muDoubleComplex * B
• int ldb
• int * info
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSpotri

musolverStatus_t MUSOLVERAPI musolverDnSpotri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, float *A, const int lda, int *info)

POTRI inverts a symmetric/hermitian positive definite matrix A.

The inverse of matrix formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]} is computed as

formula {"type":"element","name":"formula","attributes":{"id":"72"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A^{-1} = U^{-1} {U^{-1}}' & \\: \\text{if uplo is upper, or}\\\\\n A^{-1} = {L^{-1}}' L^{-1} & \\: \\text{if uplo is lower.}\n \\end{array}\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"73"},"children":[{"type":"text","text":"$U$"}]} or formula {"type":"element","name":"formula","attributes":{"id":"74"},"children":[{"type":"text","text":"$L$"}]} is the triangular factor of the Cholesky factorization of formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]} returned by POTRF.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the factorization is upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the factor L or U of the Cholesky factorization of A returned by POTRF. On exit, the inverse of A if info = 0.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• info: pointer to a int on the GPU.
  If info = 0, successful exit for inversion of A. If info = i > 0, A is singular. L[i,i] or U[i,i] is zero.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDpotri

musolverStatus_t MUSOLVERAPI musolverDnDpotri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, double *A, const int lda, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCpotri

musolverStatus_t MUSOLVERAPI musolverDnCpotri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZpotri

musolverStatus_t MUSOLVERAPI musolverDnZpotri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSpotriBatched

musolverStatus_t MUSOLVERAPI musolverDnSpotriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, int *info, const int batch_count)

POTRI_BATCHED inverts a batch of symmetric/hermitian positive definite matrices formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}.

The inverse of matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} in the batch is computed as

formula {"type":"element","name":"formula","attributes":{"id":"75"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j^{-1} = U_j^{-1} {U_j^{-1}}' & \\: \\text{if uplo is upper, or}\\\\\n A_j^{-1} = {L_j^{-1}}' L_j^{-1} & \\: \\text{if uplo is lower.}\n \\end{array}\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} or formula {"type":"element","name":"formula","attributes":{"id":"26"},"children":[{"type":"text","text":"$L_j$"}]} is the triangular factor of the Cholesky factorization of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} returned by POTRF_BATCHED.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the factorization is upper or lower triangular. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of matrix A_j.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the factor L_j or U_j of the Cholesky factorization of A_j returned by POTRF_BATCHED. On exit, the inverses of A_j if info[j] = 0.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for inversion of A_j. If info[j] = i > 0, A_j is singular. L_j[i,i] or U_j[i,i] is zero.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDpotriBatched

musolverStatus_t MUSOLVERAPI musolverDnDpotriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCpotriBatched

musolverStatus_t MUSOLVERAPI musolverDnCpotriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZpotriBatched

musolverStatus_t MUSOLVERAPI musolverDnZpotriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvd

musolverStatus_t MUSOLVERAPI musolverDnSgesvd(musolverDnHandle_t handle, signed char jobu, signed char jobvt, int m, int n, float *A, int lda, float *S, float *U, int ldu, float *VT, int ldvt, float *work, int lwork, float *rwork, int *devInfo)

GESVD computes the singular values and optionally the singular vectors of a general m-by-n matrix A (Singular Value Decomposition).

The SVD of matrix A is given by:

formula {"type":"element","name":"formula","attributes":{"id":"76"},"children":[{"type":"text","text":"\\[\n A = U S V'\n \\]"}]}

where the m-by-n matrix S is zero except, possibly, for its min(m,n) diagonal elements, which are the singular values of A. U and V are orthogonal (unitary) matrices. The first min(m,n) columns of U and V are the left and right singular vectors of A, respectively.

The computation of the singular vectors is optional and it is controlled by the function arguments left_svect and right_svect as described below. When computed, this function returns the transpose (or transpose conjugate) of the right singular vectors, i.e. the rows of V'.

left_svect and right_svect are mublasSvect enums that can take the following values:

• MUBLAS_SVECT_ALL: the entire matrix U (or V') is computed,

• MUBLAS_SVECT_SINGULAR: only the singular vectors (first min(m,n) columns of U or rows of V') are computed,

• MUBLAS_SVECT_OVERWRITE: the first columns (or rows) of A are overwritten with the singular vectors, or

• MUBLAS_SVECT_NONE: no columns (or rows) of U (or V') are computed, i.e. no singular vectors.

left_svect and right_svect cannot both be set to overwrite. When neither is set to overwrite, the contents of A are destroyed by the time the function returns.

注意：When m >> n (or n >> m) the algorithm could be sped up by compressing the matrix A via a QR (or LQ) factorization, and working with the triangular factor afterwards (thin-SVD). If the singular vectors are also requested, its computation could be sped up as well via executing some intermediate operations out-of-place, and relying more on matrix multiplications (GEMMs); this will require, however, a larger memory workspace. The parameter fast_alg controls whether the fast algorithm is executed or not. For more details, see the "Tuning muSOLVER performance" and "Memory model" sections of the documentation.

Parameters:

• handle: musolverDnHandle_t .
• left_svect: mublasSvect.
  Specifies how the left singular vectors are computed.
• right_svect: mublasSvect.
  Specifies how the right singular vectors are computed.
• m: int. m >= 0.
  The number of rows of matrix A.
• n: int. n >= 0.
  The number of columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, if left_svect (or right_svect) is equal to overwrite, the first columns (or rows) contain the left (or right) singular vectors; otherwise, the contents of A are destroyed.
• lda: int. lda >= m.
  The leading dimension of A.
• S: pointer to real type. Array on the GPU of dimension min(m,n).
  The singular values of A in decreasing order.
• U: pointer to type. Array on the GPU of dimension ldumin(m,n) if left_svect is set to singular, or ldum when left_svect is equal to all.
  The matrix of left singular vectors stored as columns. Not referenced if left_svect is set to overwrite or none.
• ldu: int. ldu >= m if left_svect is all or singular; ldu >= 1 otherwise.
  The leading dimension of U.
• V: pointer to type. Array on the GPU of dimension ldv*n.
  The matrix of right singular vectors stored as rows (transposed / conjugate-transposed). Not referenced if right_svect is set to overwrite or none.
• ldv: int. ldv >= n if right_svect is all; ldv >= min(m,n) if right_svect is set to singular; or ldv >= 1 otherwise.
  The leading dimension of V.
• E: pointer to real type. Array on the GPU of dimension min(m,n)-1.
  This array is used to work internally with the bidiagonal matrix B associated with A (using BDSQR). On exit, if info > 0, it contains the unconverged off-diagonal elements of B (or properly speaking, a bidiagonal matrix orthogonally equivalent to B). The diagonal elements of this matrix are in S; those that converged correspond to a subset of the singular values of A (not necessarily ordered).
• fast_alg: mublasWorkmode.
  If set to MUBLAS_OUTOFPLACE, the function will execute the fast thin-SVD version of the algorithm when possible.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, BDSQR did not converge. i elements of E did not converge to zero.

Parameters:

• musolverDnHandle_t handle
• signed char jobu
• signed char jobvt
• int m
• int n
• float * A
• int lda
• float * S
• float * U
• int ldu
• float * VT
• int ldvt
• float * work
• int lwork
• float * rwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvd

musolverStatus_t MUSOLVERAPI musolverDnDgesvd(musolverDnHandle_t handle, signed char jobu, signed char jobvt, int m, int n, double *A, int lda, double *S, double *U, int ldu, double *VT, int ldvt, double *work, int lwork, double *rwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• signed char jobu
• signed char jobvt
• int m
• int n
• double * A
• int lda
• double * S
• double * U
• int ldu
• double * VT
• int ldvt
• double * work
• int lwork
• double * rwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvd

musolverStatus_t MUSOLVERAPI musolverDnCgesvd(musolverDnHandle_t handle, signed char jobu, signed char jobvt, int m, int n, muComplex *A, int lda, float *S, muComplex *U, int ldu, muComplex *VT, int ldvt, muComplex *work, int lwork, float *rwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• signed char jobu
• signed char jobvt
• int m
• int n
• muComplex * A
• int lda
• float * S
• muComplex * U
• int ldu
• muComplex * VT
• int ldvt
• muComplex * work
• int lwork
• float * rwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvd

musolverStatus_t MUSOLVERAPI musolverDnZgesvd(musolverDnHandle_t handle, signed char jobu, signed char jobvt, int m, int n, muDoubleComplex *A, int lda, double *S, muDoubleComplex *U, int ldu, muDoubleComplex *VT, int ldvt, muDoubleComplex *work, int lwork, double *rwork, int *devInfo)

Parameters:

• musolverDnHandle_t handle
• signed char jobu
• signed char jobvt
• int m
• int n
• muDoubleComplex * A
• int lda
• double * S
• muDoubleComplex * U
• int ldu
• muDoubleComplex * VT
• int ldvt
• muDoubleComplex * work
• int lwork
• double * rwork
• int * devInfo

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSgesvd_bufferSize(musolverDnHandle_t handle, int m, int n, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDgesvd_bufferSize(musolverDnHandle_t handle, int m, int n, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCgesvd_bufferSize(musolverDnHandle_t handle, int m, int n, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZgesvd_bufferSize(musolverDnHandle_t handle, int m, int n, int *buffersize)

Parameters:

• musolverDnHandle_t handle
• int m
• int n
• int * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvdBatched

musolverStatus_t MUSOLVERAPI musolverDnSgesvdBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, float *const A[], const int lda, float *S, const int strideS, float *U, const int ldu, const int strideU, float *V, const int ldv, const int strideV, float *E, const int strideE, const mublasWorkmode fast_alg, int *info, const int batch_count)

GESVD_BATCHED computes the singular values and optionally the singular vectors of a batch of general m-by-n matrix A (Singular Value Decomposition).

The SVD of matrix A_j in the batch is given by:

formula {"type":"element","name":"formula","attributes":{"id":"77"},"children":[{"type":"text","text":"\\[\n A_j = U_j S_j V_j'\n \\]"}]}

where the m-by-n matrix formula {"type":"element","name":"formula","attributes":{"id":"78"},"children":[{"type":"text","text":"$S_j$"}]} is zero except, possibly, for its min(m,n) diagonal elements, which are the singular values of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}. formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"79"},"children":[{"type":"text","text":"$V_j$"}]} are orthogonal (unitary) matrices. The first min(m,n) columns of formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"79"},"children":[{"type":"text","text":"$V_j$"}]} are the left and right singular vectors of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}, respectively.

The computation of the singular vectors is optional and it is controlled by the function arguments left_svect and right_svect as described below. When computed, this function returns the transpose (or transpose conjugate) of the right singular vectors, i.e. the rows of formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}.

left_svect and right_svect are mublasSvect enums that can take the following values:

• MUBLAS_SVECT_ALL: the entire matrix formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} (or formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}) is computed,

• MUBLAS_SVECT_SINGULAR: only the singular vectors (first min(m,n) columns of formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} or rows of formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}) are computed,

• MUBLAS_SVECT_OVERWRITE: the first columns (or rows) of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} are overwritten with the singular vectors, or

• MUBLAS_SVECT_NONE: no columns (or rows) of formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} (or formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}) are computed, i.e. no singular vectors.

left_svect and right_svect cannot both be set to overwrite. When neither is set to overwrite, the contents of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} are destroyed by the time the function returns.

注意：When m >> n (or n >> m) the algorithm could be sped up by compressing the matrix formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} via a QR (or LQ) factorization, and working with the triangular factor afterwards (thin-SVD). If the singular vectors are also requested, its computation could be sped up as well via executing some intermediate operations out-of-place, and relying more on matrix multiplications (GEMMs); this will require, however, a larger memory workspace. The parameter fast_alg controls whether the fast algorithm is executed or not. For more details, see the "Tuning muSOLVER performance" and "Memory model" sections of the documentation.

Parameters:

• handle: musolverDnHandle_t .
• left_svect: mublasSvect.
  Specifies how the left singular vectors are computed.
• right_svect: mublasSvect.
  Specifies how the right singular vectors are computed.
• m: int. m >= 0.
  The number of rows of all matrices A_j in the batch.
• n: int. n >= 0.
  The number of columns of all matrices A_j in the batch.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, if left_svect (or right_svect) is equal to overwrite, the first columns (or rows) of A_j contain the left (or right) corresponding singular vectors; otherwise, the contents of A_j are destroyed.
• lda: int. lda >= m.
  The leading dimension of A_j.
• S: pointer to real type. Array on the GPU (the size depends on the value of strideS).
  The singular values of A_j in decreasing order.
• strideS: int.
  Stride from the start of one vector S_j to the next one S_(j+1). There is no restriction for the value of strideS. Normal use case is strideS >= min(m,n).
• U: pointer to type. Array on the GPU (the side depends on the value of strideU).
  The matrices U_j of left singular vectors stored as columns. Not referenced if left_svect is set to overwrite or none.
• ldu: int. ldu >= m if left_svect is all or singular; ldu >= 1 otherwise.
  The leading dimension of U_j.
• strideU: int.
  Stride from the start of one matrix U_j to the next one U_(j+1). There is no restriction for the value of strideU. Normal use case is strideU >= ldumin(m,n) if left_svect is set to singular, or strideU >= ldum when left_svect is equal to all.
• V: pointer to type. Array on the GPU (the size depends on the value of strideV).
  The matrices V_j of right singular vectors stored as rows (transposed / conjugate-transposed). Not referenced if right_svect is set to overwrite or none.
• ldv: int. ldv >= n if right_svect is all; ldv >= min(m,n) if right_svect is set to singular; or ldv >= 1 otherwise.
  The leading dimension of V.
• strideV: int.
  Stride from the start of one matrix V_j to the next one V_(j+1). There is no restriction for the value of strideV. Normal use case is strideV >= ldv*n.
• E: pointer to real type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the bidiagonal matrix B_j associated with A_j (using BDSQR). On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of B_j (or properly speaking, a bidiagonal matrix orthogonally equivalent to B_j). The diagonal elements of this matrix are in S_j; those that converged correspond to a subset of the singular values of A_j (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= min(m,n)-1.
• fast_alg: mublasWorkmode.
  If set to MUBLAS_OUTOFPLACE, the function will execute the fast thin-SVD version of the algorithm when possible.
• info: pointer to a int on the GPU.
  If info[j] = 0, successful exit. If info[j] = i > 0, BDSQR did not converge. i elements of E_j did not converge to zero.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• float *const A
• const int lda
• float * S
• const int strideS
• float * U
• const int ldu
• const int strideU
• float * V
• const int ldv
• const int strideV
• float * E
• const int strideE
• const mublasWorkmode fast_alg
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvdBatched

musolverStatus_t MUSOLVERAPI musolverDnDgesvdBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, double *const A[], const int lda, double *S, const int strideS, double *U, const int ldu, const int strideU, double *V, const int ldv, const int strideV, double *E, const int strideE, const mublasWorkmode fast_alg, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• double *const A
• const int lda
• double * S
• const int strideS
• double * U
• const int ldu
• const int strideU
• double * V
• const int ldv
• const int strideV
• double * E
• const int strideE
• const mublasWorkmode fast_alg
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvdBatched

musolverStatus_t MUSOLVERAPI musolverDnCgesvdBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, muComplex *const A[], const int lda, float *S, const int strideS, muComplex *U, const int ldu, const int strideU, muComplex *V, const int ldv, const int strideV, float *E, const int strideE, const mublasWorkmode fast_alg, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• muComplex *const A
• const int lda
• float * S
• const int strideS
• muComplex * U
• const int ldu
• const int strideU
• muComplex * V
• const int ldv
• const int strideV
• float * E
• const int strideE
• const mublasWorkmode fast_alg
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvdBatched

musolverStatus_t MUSOLVERAPI musolverDnZgesvdBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, muDoubleComplex *const A[], const int lda, double *S, const int strideS, muDoubleComplex *U, const int ldu, const int strideU, muDoubleComplex *V, const int ldv, const int strideV, double *E, const int strideE, const mublasWorkmode fast_alg, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• muDoubleComplex *const A
• const int lda
• double * S
• const int strideS
• muDoubleComplex * U
• const int ldu
• const int strideU
• muDoubleComplex * V
• const int ldv
• const int strideV
• double * E
• const int strideE
• const mublasWorkmode fast_alg
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvdaStridedBatched

musolverStatus_t MUSOLVERAPI musolverDnSgesvdaStridedBatched(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, float *A, int lda, long long int strideA, float *S, long long int strideS, float *U, int ldu, long long int strideU, float *V, int ldv, long long int strideV, float *work, int lwork, int *info, double *h_R_nrmF, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• float * A
• int lda
• long long int strideA
• float * S
• long long int strideS
• float * U
• int ldu
• long long int strideU
• float * V
• int ldv
• long long int strideV
• float * work
• int lwork
• int * info
• double * h_R_nrmF
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvdaStridedBatched

musolverStatus_t MUSOLVERAPI musolverDnDgesvdaStridedBatched(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, double *A, int lda, long long int strideA, double *S, long long int strideS, double *U, int ldu, long long int strideU, double *V, int ldv, long long int strideV, double *work, int lwork, int *info, double *h_R_nrmF, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• double * A
• int lda
• long long int strideA
• double * S
• long long int strideS
• double * U
• int ldu
• long long int strideU
• double * V
• int ldv
• long long int strideV
• double * work
• int lwork
• int * info
• double * h_R_nrmF
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvdaStridedBatched

musolverStatus_t MUSOLVERAPI musolverDnCgesvdaStridedBatched(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, muComplex *A, int lda, long long int strideA, float *S, long long int strideS, muComplex *U, int ldu, long long int strideU, muComplex *V, int ldv, long long int strideV, muComplex *work, int lwork, int *info, double *h_R_nrmF, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• muComplex * A
• int lda
• long long int strideA
• float * S
• long long int strideS
• muComplex * U
• int ldu
• long long int strideU
• muComplex * V
• int ldv
• long long int strideV
• muComplex * work
• int lwork
• int * info
• double * h_R_nrmF
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvdaStridedBatched

musolverStatus_t MUSOLVERAPI musolverDnZgesvdaStridedBatched(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, muDoubleComplex *A, int lda, long long int strideA, double *S, long long int strideS, muDoubleComplex *U, int ldu, long long int strideU, muDoubleComplex *V, int ldv, long long int strideV, muDoubleComplex *work, int lwork, int *info, double *h_R_nrmF, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• muDoubleComplex * A
• int lda
• long long int strideA
• double * S
• long long int strideS
• muDoubleComplex * U
• int ldu
• long long int strideU
• muDoubleComplex * V
• int ldv
• long long int strideV
• muDoubleComplex * work
• int lwork
• int * info
• double * h_R_nrmF
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvdaStridedBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSgesvdaStridedBatched_bufferSize(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, const float *A, int lda, long long int strideA, const float *S, long long int strideS, const float *U, int ldu, long long int strideU, const float *V, int ldv, long long int strideV, int *lwork, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• const float * A
• int lda
• long long int strideA
• const float * S
• long long int strideS
• const float * U
• int ldu
• long long int strideU
• const float * V
• int ldv
• long long int strideV
• int * lwork
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvdaStridedBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDgesvdaStridedBatched_bufferSize(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, const double *A, int lda, long long int strideA, const double *S, long long int strideS, const double *U, int ldu, long long int strideU, const double *V, int ldv, long long int strideV, int *lwork, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• const double * A
• int lda
• long long int strideA
• const double * S
• long long int strideS
• const double * U
• int ldu
• long long int strideU
• const double * V
• int ldv
• long long int strideV
• int * lwork
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvdaStridedBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCgesvdaStridedBatched_bufferSize(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, const muComplex *A, int lda, long long int strideA, const float *S, long long int strideS, const muComplex *U, int ldu, long long int strideU, const muComplex *V, int ldv, long long int strideV, int *lwork, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• const muComplex * A
• int lda
• long long int strideA
• const float * S
• long long int strideS
• const muComplex * U
• int ldu
• long long int strideU
• const muComplex * V
• int ldv
• long long int strideV
• int * lwork
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvdaStridedBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZgesvdaStridedBatched_bufferSize(musolverDnHandle_t handle, musolverEigMode_t jobz, int rank, int m, int n, const muDoubleComplex *A, int lda, long long int strideA, const double *S, long long int strideS, const muDoubleComplex *U, int ldu, long long int strideU, const muDoubleComplex *V, int ldv, long long int strideV, int *lwork, int batchSize)

Parameters:

• musolverDnHandle_t handle
• musolverEigMode_t jobz
• int rank
• int m
• int n
• const muDoubleComplex * A
• int lda
• long long int strideA
• const double * S
• long long int strideS
• const muDoubleComplex * U
• int ldu
• long long int strideU
• const muDoubleComplex * V
• int ldv
• long long int strideV
• int * lwork
• int batchSize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvdj

musolverStatus_t MUSOLVERAPI musolverDnSgesvdj(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, float *A, const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *S, float *U, const int ldu, float *V, const int ldv, int *info)

GESVDJ computes the singular values and optionally the singular vectors of a general m-by-n matrix A (Singular Value Decomposition).

The SVD of matrix A is given by:

formula {"type":"element","name":"formula","attributes":{"id":"76"},"children":[{"type":"text","text":"\\[\n A = U S V'\n \\]"}]}

where the m-by-n matrix S is zero except, possibly, for its min(m,n) diagonal elements, which are the singular values of A. U and V are orthogonal (unitary) matrices. The first min(m,n) columns of U and V are the left and right singular vectors of A, respectively.

The computation of the singular vectors is optional and it is controlled by the function arguments left_svect and right_svect as described below. When computed, this function returns the transpose (or transpose conjugate) of the right singular vectors, i.e. the rows of V'.

left_svect and right_svect are mublasSvect enums that can take the following values:

• MUBLAS_SVECT_ALL: the entire matrix U (or V') is computed,

• MUBLAS_SVECT_SINGULAR: the singular vectors (first min(m,n) columns of U or rows of V') are computed, or

• MUBLAS_SVECT_NONE: no columns (or rows) of U (or V') are computed, i.e. no singular vectors.

The singular values are computed by applying QR factorization to AV if m >= n (resp. LQ factorization to U'A if m < n), where V (resp. U) is found as the eigenvectors of A'A (resp. AA') using the Jacobi eigenvalue algorithm.

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• left_svect: mublasSvect.
  Specifies how the left singular vectors are computed. MUBLAS_SVECT_OVERWRITE is not supported.
• right_svect: mublasSvect.
  Specifies how the right singular vectors are computed. MUBLAS_SVECT_OVERWRITE is not supported.
• m: int. m >= 0.
  The number of rows of matrix A.
• n: int. n >= 0.
  The number of columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the contents of A are destroyed.
• lda: int. lda >= m.
  The leading dimension of A.
• abstol: real type.
  The absolute tolerance. The algorithm is considered to have converged once off(A'A) is <= norm(A'A) * abstol [resp. off(AA') <= norm(AA') abstol]. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to real type on the GPU.
  The Frobenius norm of the off-diagonal elements of A'A (resp. AA') at the final iteration.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to a int on the GPU.
  The actual number of sweeps (iterations) used by the algorithm.
• S: pointer to real type. Array on the GPU of dimension min(m,n).
  The singular values of A in decreasing order.
• U: pointer to type. Array on the GPU of dimension ldumin(m,n) if left_svect is set to singular, or ldum when left_svect is equal to all.
  The matrix of left singular vectors stored as columns. Not referenced if left_svect is set to none.
• ldu: int. ldu >= m if left_svect is set to all or singular; ldu >= 1 otherwise.
  The leading dimension of U.
• V: pointer to type. Array on the GPU of dimension ldv*n.
  The matrix of right singular vectors stored as rows (transposed / conjugate-transposed). Not referenced if right_svect is set to none.
• ldv: int. ldv >= n if right_svect is set to all; ldv >= min(m,n) if right_svect is set to singular; or ldv >= 1 otherwise.
  The leading dimension of V.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = 1, the algorithm did not converge.

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• float * A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * S
• float * U
• const int ldu
• float * V
• const int ldv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvdj

musolverStatus_t MUSOLVERAPI musolverDnDgesvdj(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, double *A, const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *S, double *U, const int ldu, double *V, const int ldv, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• double * A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * S
• double * U
• const int ldu
• double * V
• const int ldv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvdj

musolverStatus_t MUSOLVERAPI musolverDnCgesvdj(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, muComplex *A, const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *S, muComplex *U, const int ldu, muComplex *V, const int ldv, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• muComplex * A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * S
• muComplex * U
• const int ldu
• muComplex * V
• const int ldv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvdj

musolverStatus_t MUSOLVERAPI musolverDnZgesvdj(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, muDoubleComplex *A, const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *S, muDoubleComplex *U, const int ldu, muDoubleComplex *V, const int ldv, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• muDoubleComplex * A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * S
• muDoubleComplex * U
• const int ldu
• muDoubleComplex * V
• const int ldv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSgesvdjBatched

musolverStatus_t MUSOLVERAPI musolverDnSgesvdjBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, float *const A[], const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *S, const int strideS, float *U, const int ldu, const int strideU, float *V, const int ldv, const int strideV, int *info, const int batch_count)

GESVDJ_BATCHED computes the singular values and optionally the singular vectors of a batch of general m-by-n matrix A (Singular Value Decomposition).

The SVD of matrix A_j in the batch is given by:

formula {"type":"element","name":"formula","attributes":{"id":"77"},"children":[{"type":"text","text":"\\[\n A_j = U_j S_j V_j'\n \\]"}]}

where the m-by-n matrix formula {"type":"element","name":"formula","attributes":{"id":"78"},"children":[{"type":"text","text":"$S_j$"}]} is zero except, possibly, for its min(m,n) diagonal elements, which are the singular values of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}. formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"79"},"children":[{"type":"text","text":"$V_j$"}]} are orthogonal (unitary) matrices. The first min(m,n) columns of formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"79"},"children":[{"type":"text","text":"$V_j$"}]} are the left and right singular vectors of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}, respectively.

The computation of the singular vectors is optional and it is controlled by the function arguments left_svect and right_svect as described below. When computed, this function returns the transpose (or transpose conjugate) of the right singular vectors, i.e. the rows of formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}.

left_svect and right_svect are mublasSvect enums that can take the following values:

• MUBLAS_SVECT_ALL: the entire matrix formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} (or formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}) is computed,

• MUBLAS_SVECT_SINGULAR: the singular vectors (first min(m,n) columns of formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} or rows of formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}) are computed, or

• MUBLAS_SVECT_NONE: no columns (or rows) of formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} (or formula {"type":"element","name":"formula","attributes":{"id":"80"},"children":[{"type":"text","text":"$V_j'$"}]}) are computed, i.e. no singular vectors.

The singular values are computed by applying QR factorization to formula {"type":"element","name":"formula","attributes":{"id":"81"},"children":[{"type":"text","text":"$A_jV_j$"}]} if m >= n (resp. LQ factorization to formula {"type":"element","name":"formula","attributes":{"id":"82"},"children":[{"type":"text","text":"$U_j'A_j$"}]} if m < n), where formula {"type":"element","name":"formula","attributes":{"id":"79"},"children":[{"type":"text","text":"$V_j$"}]} (resp. formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]}) is found as the eigenvectors of formula {"type":"element","name":"formula","attributes":{"id":"83"},"children":[{"type":"text","text":"$A_j'A_j$"}]} (resp. formula {"type":"element","name":"formula","attributes":{"id":"84"},"children":[{"type":"text","text":"$A_jA_j'$"}]}) using the Jacobi eigenvalue algorithm.

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• left_svect: mublasSvect.
  Specifies how the left singular vectors are computed. MUBLAS_SVECT_OVERWRITE is not supported.
• right_svect: mublasSvect.
  Specifies how the right singular vectors are computed. MUBLAS_SVECT_OVERWRITE is not supported.
• m: int. m >= 0.
  The number of rows of all matrices A_j in the batch.
• n: int. n >= 0.
  The number of columns of all matrices A_j in the batch.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the contents of A_j are destroyed.
• lda: int. lda >= m.
  The leading dimension of A_j.
• abstol: real type.
  The absolute tolerance. The algorithm is considered to have converged once off(A_j'A_j) is <= norm(A_j'A_j) * abstol [resp. off(A_jA_j') <= norm(A_jA_j') * abstol]. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to real type on the GPU.
  The Frobenius norm of the off-diagonal elements of A_j'A_j (resp. A_jA_j') at the final iteration.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to int. Array of batch_count integers on the GPU.
  The actual number of sweeps (iterations) used by the algorithm for each batch instance.
• S: pointer to real type. Array on the GPU (the size depends on the value of strideS).
  The singular values of A_j in decreasing order.
• strideS: int.
  Stride from the start of one vector S_j to the next one S_(j+1). There is no restriction for the value of strideS. Normal use case is strideS >= min(m,n).
• U: pointer to type. Array on the GPU (the side depends on the value of strideU).
  The matrices U_j of left singular vectors stored as columns. Not referenced if left_svect is set to none.
• ldu: int. ldu >= m if left_svect is set to all or singular; ldu >= 1 otherwise.
  The leading dimension of U_j.
• strideU: int.
  Stride from the start of one matrix U_j to the next one U_(j+1). There is no restriction for the value of strideU. Normal use case is strideU >= ldumin(m,n) if left_svect is set to singular, or strideU >= ldum when left_svect is equal to all.
• V: pointer to type. Array on the GPU (the size depends on the value of strideV).
  The matrices V_j of right singular vectors stored as rows (transposed / conjugate-transposed). Not referenced if right_svect is set to none.
• ldv: int. ldv >= n if right_svect is set to all; ldv >= min(m,n) if right_svect is set to singular; or ldv >= 1 otherwise.
  The leading dimension of V.
• strideV: int.
  Stride from the start of one matrix V_j to the next one V_(j+1). There is no restriction for the value of strideV. Normal use case is strideV >= ldv*n.
• info: pointer to a int on the GPU.
  If info[j] = 0, successful exit. If info[j] = 1, the algorithm did not converge.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• float *const A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * S
• const int strideS
• float * U
• const int ldu
• const int strideU
• float * V
• const int ldv
• const int strideV
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDgesvdjBatched

musolverStatus_t MUSOLVERAPI musolverDnDgesvdjBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, double *const A[], const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *S, const int strideS, double *U, const int ldu, const int strideU, double *V, const int ldv, const int strideV, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• double *const A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * S
• const int strideS
• double * U
• const int ldu
• const int strideU
• double * V
• const int ldv
• const int strideV
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCgesvdjBatched

musolverStatus_t MUSOLVERAPI musolverDnCgesvdjBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, muComplex *const A[], const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *S, const int strideS, muComplex *U, const int ldu, const int strideU, muComplex *V, const int ldv, const int strideV, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• muComplex *const A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * S
• const int strideS
• muComplex * U
• const int ldu
• const int strideU
• muComplex * V
• const int ldv
• const int strideV
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZgesvdjBatched

musolverStatus_t MUSOLVERAPI musolverDnZgesvdjBatched(musolverDnHandle_t handle, const mublasSvect left_svect, const mublasSvect right_svect, const int m, const int n, muDoubleComplex *const A[], const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *S, const int strideS, muDoubleComplex *U, const int ldu, const int strideU, muDoubleComplex *V, const int ldv, const int strideV, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasSvect left_svect
• const mublasSvect right_svect
• const int m
• const int n
• muDoubleComplex *const A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * S
• const int strideS
• muDoubleComplex * U
• const int ldu
• const int strideU
• muDoubleComplex * V
• const int ldv
• const int strideV
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsytrd

musolverStatus_t MUSOLVERAPI musolverDnSsytrd(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *D, float *E, float *tau)

SYTRD computes the tridiagonal form of a real symmetric matrix A.

(This is the blocked version of the algorithm).

The tridiagonal form is given by:

formula {"type":"element","name":"formula","attributes":{"id":"85"},"children":[{"type":"text","text":"\\[\n T = Q' A Q\n \\]"}]}

where T is symmetric tridiagonal and Q is an orthogonal matrix represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"86"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Q = H_1H_2\\cdots H_{n-1} & \\: \\text{if uplo indicates lower, or}\\\\\n Q = H_{n-1}H_{n-2}\\cdots H_1 & \\: \\text{if uplo indicates upper.}\n \\end{array}\n \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"87"},"children":[{"type":"text","text":"\\[\n H_i = I - \\text{tau}[i] \\cdot v_i v_i'\n \\]"}]}

where tau[i] is the corresponding Householder scalar. When uplo indicates lower, the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"88"},"children":[{"type":"text","text":"$v_i[i+1] = 1$"}]}. If uplo indicates upper, the last n-i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"31"},"children":[{"type":"text","text":"$v_i[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix to be factored. On exit, if upper, then the elements on the diagonal and superdiagonal contain the tridiagonal form T; the elements above the superdiagonal contain the first i-1 elements of the Householder vectors v_i stored as columns. If lower, then the elements on the diagonal and subdiagonal contain the tridiagonal form T; the elements below the subdiagonal contain the last n-i-1 elements of the Householder vectors v_i stored as columns.
• lda: int. lda >= n.
  The leading dimension of A.
• D: pointer to type. Array on the GPU of dimension n.
  The diagonal elements of T.
• E: pointer to type. Array on the GPU of dimension n-1.
  The off-diagonal elements of T.
• tau: pointer to type. Array on the GPU of dimension n-1.
  The Householder scalars.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * D
• float * E
• float * tau

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsytrd

musolverStatus_t MUSOLVERAPI musolverDnDsytrd(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *D, double *E, double *tau)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * D
• double * E
• double * tau

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChetrd

musolverStatus_t MUSOLVERAPI musolverDnChetrd(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, float *D, float *E, muComplex *tau)

HETRD computes the tridiagonal form of a complex hermitian matrix A.

(This is the blocked version of the algorithm).

The tridiagonal form is given by:

formula {"type":"element","name":"formula","attributes":{"id":"85"},"children":[{"type":"text","text":"\\[\n T = Q' A Q\n \\]"}]}

where T is hermitian tridiagonal and Q is an unitary matrix represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"86"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Q = H_1H_2\\cdots H_{n-1} & \\: \\text{if uplo indicates lower, or}\\\\\n Q = H_{n-1}H_{n-2}\\cdots H_1 & \\: \\text{if uplo indicates upper.}\n \\end{array}\n \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"7"},"children":[{"type":"text","text":"$H_i$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"87"},"children":[{"type":"text","text":"\\[\n H_i = I - \\text{tau}[i] \\cdot v_i v_i'\n \\]"}]}

where tau[i] is the corresponding Householder scalar. When uplo indicates lower, the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"88"},"children":[{"type":"text","text":"$v_i[i+1] = 1$"}]}. If uplo indicates upper, the last n-i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"8"},"children":[{"type":"text","text":"$v_i$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"31"},"children":[{"type":"text","text":"$v_i[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the hermitian matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix to be factored. On exit, if upper, then the elements on the diagonal and superdiagonal contain the tridiagonal form T; the elements above the superdiagonal contain the first i-1 elements of the Householder vectors v_i stored as columns. If lower, then the elements on the diagonal and subdiagonal contain the tridiagonal form T; the elements below the subdiagonal contain the last n-i-1 elements of the Householder vectors v_i stored as columns.
• lda: int. lda >= n.
  The leading dimension of A.
• D: pointer to real type. Array on the GPU of dimension n.
  The diagonal elements of T.
• E: pointer to real type. Array on the GPU of dimension n-1.
  The off-diagonal elements of T.
• tau: pointer to type. Array on the GPU of dimension n-1.
  The Householder scalars.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• float * D
• float * E
• muComplex * tau

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhetrd

musolverStatus_t MUSOLVERAPI musolverDnZhetrd(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, double *D, double *E, muDoubleComplex *tau)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• double * D
• double * E
• muDoubleComplex * tau

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsytrdBatched

musolverStatus_t MUSOLVERAPI musolverDnSsytrdBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, float *tau, const int strideP, const int batch_count)

SYTRD_BATCHED computes the tridiagonal form of a batch of real symmetric matrices A_j.

(This is the blocked version of the algorithm).

The tridiagonal form of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is given by:

formula {"type":"element","name":"formula","attributes":{"id":"89"},"children":[{"type":"text","text":"\\[\n T_j = Q_j' A_j Q_j\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"90"},"children":[{"type":"text","text":"$T_j$"}]} is symmetric tridiagonal and formula {"type":"element","name":"formula","attributes":{"id":"34"},"children":[{"type":"text","text":"$Q_j$"}]} is an orthogonal matrix represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"91"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Q_j = H_{j_1}H_{j_2}\\cdots H_{j_{n-1}} & \\: \\text{if uplo indicates\nlower, or}\\\\ Q_j = H_{j_{n-1}}H_{j_{n-2}}\\cdots H_{j_1} & \\: \\text{if uplo\nindicates upper.} \\end{array} \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"36"},"children":[{"type":"text","text":"$H_{j_i}$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"92"},"children":[{"type":"text","text":"\\[\n H_{j_i} = I - \\text{tau}_j[i] \\cdot v_{j_i} v_{j_i}'\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"93"},"children":[{"type":"text","text":"$\\text{tau}_j[i]$"}]} is the corresponding Householder scalar. When uplo indicates lower, the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"38"},"children":[{"type":"text","text":"$v_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"55"},"children":[{"type":"text","text":"$v_{j_i}[i+1] = 1$"}]}. If uplo indicates upper, the last n-i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"38"},"children":[{"type":"text","text":"$v_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"39"},"children":[{"type":"text","text":"$v_{j_i}[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrix A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of the matrices A_j.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j to be factored. On exit, if upper, then the elements on the diagonal and superdiagonal contain the tridiagonal form T_j; the elements above the superdiagonal contain the first i-1 elements of the Householder vectors v_(j_i) stored as columns. If lower, then the elements on the diagonal and subdiagonal contain the tridiagonal form T_j; the elements below the subdiagonal contain the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
• lda: int. lda >= n.
  The leading dimension of A_j.
• D: pointer to type. Array on the GPU (the size depends on the value of strideD).
  The diagonal elements of T_j.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use case is strideD >= n.
• E: pointer to type. Array on the GPU (the size depends on the value of strideE).
  The off-diagonal elements of T_j.
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
• tau: pointer to type. Array on the GPU (the size depends on the value of strideP).
  Contains the vectors tau_j of corresponding Householder scalars.
• strideP: int.
  Stride from the start of one vector tau_j to the next one tau_(j+1). There is no restriction for the value of strideP. Normal use is strideP >= n-1.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• float * tau
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsytrdBatched

musolverStatus_t MUSOLVERAPI musolverDnDsytrdBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, double *tau, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• double * tau
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChetrdBatched

musolverStatus_t MUSOLVERAPI musolverDnChetrdBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, muComplex *tau, const int strideP, const int batch_count)

HETRD_BATCHED computes the tridiagonal form of a batch of complex hermitian matrices A_j.

(This is the blocked version of the algorithm).

The tridiagonal form of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is given by:

formula {"type":"element","name":"formula","attributes":{"id":"89"},"children":[{"type":"text","text":"\\[\n T_j = Q_j' A_j Q_j\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"90"},"children":[{"type":"text","text":"$T_j$"}]} is Hermitian tridiagonal and formula {"type":"element","name":"formula","attributes":{"id":"34"},"children":[{"type":"text","text":"$Q_j$"}]} is a unitary matrix represented as the product of Householder matrices

formula {"type":"element","name":"formula","attributes":{"id":"91"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Q_j = H_{j_1}H_{j_2}\\cdots H_{j_{n-1}} & \\: \\text{if uplo indicates\nlower, or}\\\\ Q_j = H_{j_{n-1}}H_{j_{n-2}}\\cdots H_{j_1} & \\: \\text{if uplo\nindicates upper.} \\end{array} \\]"}]}

Each Householder matrix formula {"type":"element","name":"formula","attributes":{"id":"36"},"children":[{"type":"text","text":"$H_{j_i}$"}]} is given by

formula {"type":"element","name":"formula","attributes":{"id":"92"},"children":[{"type":"text","text":"\\[\n H_{j_i} = I - \\text{tau}_j[i] \\cdot v_{j_i} v_{j_i}'\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"93"},"children":[{"type":"text","text":"$\\text{tau}_j[i]$"}]} is the corresponding Householder scalar. When uplo indicates lower, the first i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"38"},"children":[{"type":"text","text":"$v_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"55"},"children":[{"type":"text","text":"$v_{j_i}[i+1] = 1$"}]}. If uplo indicates upper, the last n-i elements of the Householder vector formula {"type":"element","name":"formula","attributes":{"id":"38"},"children":[{"type":"text","text":"$v_{j_i}$"}]} are zero, and formula {"type":"element","name":"formula","attributes":{"id":"39"},"children":[{"type":"text","text":"$v_{j_i}[i] = 1$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the hermitian matrix A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of the matrices A_j.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j to be factored. On exit, if upper, then the elements on the diagonal and superdiagonal contain the tridiagonal form T_j; the elements above the superdiagonal contain the first i-1 elements of the Householder vectors v_(j_i) stored as columns. If lower, then the elements on the diagonal and subdiagonal contain the tridiagonal form T_j; the elements below the subdiagonal contain the last n-i-1 elements of the Householder vectors v_(j_i) stored as columns.
• lda: int. lda >= n.
  The leading dimension of A_j.
• D: pointer to real type. Array on the GPU (the size depends on the value of strideD).
  The diagonal elements of T_j.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use case is strideD >= n.
• E: pointer to real type. Array on the GPU (the size depends on the value of strideE).
  The off-diagonal elements of T_j.
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= n-1.
• tau: pointer to type. Array on the GPU (the size depends on the value of strideP).
  Contains the vectors tau_j of corresponding Householder scalars.
• strideP: int.
  Stride from the start of one vector tau_j to the next one tau_(j+1). There is no restriction for the value of strideP. Normal use is strideP >= n-1.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• muComplex * tau
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhetrdBatched

musolverStatus_t MUSOLVERAPI musolverDnZhetrdBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, muDoubleComplex *tau, const int strideP, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• muDoubleComplex * tau
• const int strideP
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyev

musolverStatus_t MUSOLVERAPI musolverDnSsyev(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *D, float *E, int *info)

SYEV computes the eigenvalues and optionally the eigenvectors of a real symmetric matrix A.

The eigenvalues are returned in ascending order. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the eigenvectors of A if they were computed and the algorithm converged; otherwise the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• D: pointer to type. Array on the GPU of dimension n.
  The eigenvalues of A in increasing order.
• E: pointer to type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with A. On exit, if info > 0, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues of A (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, the algorithm did not converge. i elements of E did not converge to zero.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * D
• float * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyev

musolverStatus_t MUSOLVERAPI musolverDnDsyev(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *D, double *E, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * D
• double * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheev

musolverStatus_t MUSOLVERAPI musolverDnCheev(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, float *D, float *E, int *info)

HEEV computes the eigenvalues and optionally the eigenvectors of a Hermitian matrix A.

The eigenvalues are returned in ascending order. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the Hermitian matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the eigenvectors of A if they were computed and the algorithm converged; otherwise the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• D: pointer to real type. Array on the GPU of dimension n.
  The eigenvalues of A in increasing order.
• E: pointer to real type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with A. On exit, if info > 0, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues of A (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, the algorithm did not converge. i elements of E did not converge to zero.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• float * D
• float * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheev

musolverStatus_t MUSOLVERAPI musolverDnZheev(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, double *D, double *E, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• double * D
• double * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevBatched

musolverStatus_t MUSOLVERAPI musolverDnSsyevBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count)

SYEV_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of real symmetric matrices A_j.

The eigenvalues are returned in ascending order. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and the algorithm converged; otherwise the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• D: pointer to type. Array on the GPU (the size depends on the value of strideD).
  The eigenvalues of A_j in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use case is strideD >= n.
• E: pointer to type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with A_j. On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues of A_j (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge. i elements of E_j did not converge to zero.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevBatched

musolverStatus_t MUSOLVERAPI musolverDnDsyevBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevBatched

musolverStatus_t MUSOLVERAPI musolverDnCheevBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count)

HEEV_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of Hermitian matrices A_j.

The eigenvalues are returned in ascending order. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the Hermitian matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and the algorithm converged; otherwise the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• D: pointer to real type. Array on the GPU (the size depends on the value of strideD).
  The eigenvalues of A_j in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use case is strideD >= n.
• E: pointer to real type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with A_j. On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues of A_j (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge. i elements of E_j did not converge to zero.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevBatched

musolverStatus_t MUSOLVERAPI musolverDnZheevBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevd

musolverStatus_t MUSOLVERAPI musolverDnSsyevd(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *D, float *E, int *info, void *buffer)

SYEVD computes the eigenvalues and optionally the eigenvectors of a real symmetric matrix A.

The eigenvalues are returned in ascending order. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the eigenvectors of A if they were computed and the algorithm converged; otherwise the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• D: pointer to type. Array on the GPU of dimension n.
  The eigenvalues of A in increasing order.
• E: pointer to type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with A. On exit, if info > 0, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues of A (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0 and evect is MUBLAS_EVECT_NONE, the algorithm did not converge. i elements of E did not converge to zero. If info = i > 0 and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * D
• float * E
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevd

musolverStatus_t MUSOLVERAPI musolverDnDsyevd(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *D, double *E, int *info, void *buffer)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * D
• double * E
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevd

musolverStatus_t MUSOLVERAPI musolverDnCheevd(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, float *D, float *E, int *info, void *buffer)

HEEVD computes the eigenvalues and optionally the eigenvectors of a Hermitian matrix A.

The eigenvalues are returned in ascending order. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the Hermitian matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the eigenvectors of A if they were computed and the algorithm converged; otherwise the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• D: pointer to real type. Array on the GPU of dimension n.
  The eigenvalues of A in increasing order.
• E: pointer to real type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with A. On exit, if info > 0, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues of A (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0 and evect is MUBLAS_EVECT_NONE, the algorithm did not converge. i elements of E did not converge to zero. If info = i > 0 and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• float * D
• float * E
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevd

musolverStatus_t MUSOLVERAPI musolverDnZheevd(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, double *D, double *E, int *info, void *buffer)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• double * D
• double * E
• int * info
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSsyevd_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDsyevd_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCheevd_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevd_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZheevd_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevdBatched

musolverStatus_t MUSOLVERAPI musolverDnSsyevdBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count, void *buffer)

SYEVD_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of real symmetric matrices A_j.

The eigenvalues are returned in ascending order. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and the algorithm converged; otherwise the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• D: pointer to type. Array on the GPU (the size depends on the value of strideD).
  The eigenvalues of A_j in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use case is strideD >= n.
• E: pointer to type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with A_j. On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues of A_j (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0 and evect is MUBLAS_EVECT_NONE, the algorithm did not converge. i elements of E_j did not converge to zero. If info[j] = i blockquote {"type":"element","name":"blockquote","attributes":{},"children":[{"type":"element","name":"para","attributes":{},"children":[{"type":"element","name":"zwj","attributes":{},"children":[]},{"type":"text","text":"0 and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an "}]},{"type":"text","text":"\n"}]}eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevdBatched

musolverStatus_t MUSOLVERAPI musolverDnDsyevdBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count, void *buffer)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevdBatched

musolverStatus_t MUSOLVERAPI musolverDnCheevdBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count, void *buffer)

HEEVD_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of Hermitian matrices A_j.

The eigenvalues are returned in ascending order. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect. The computed eigenvectors are orthonormal.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the Hermitian matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and the algorithm converged; otherwise the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• D: pointer to real type. Array on the GPU (the size depends on the value of strideD).
  The eigenvalues of A_j in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use case is strideD >= n.
• E: pointer to real type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with A_j. On exit, if info[j] > 0, E_j contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues of A_j (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use case is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0 and evect is MUBLAS_EVECT_NONE, the algorithm did not converge. i elements of E_j did not converge to zero. If info[j] = i blockquote {"type":"element","name":"blockquote","attributes":{},"children":[{"type":"element","name":"para","attributes":{},"children":[{"type":"element","name":"zwj","attributes":{},"children":[]},{"type":"text","text":"0 and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an "}]},{"type":"text","text":"\n"}]}eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)].
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevdBatched

musolverStatus_t MUSOLVERAPI musolverDnZheevdBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count, void *buffer)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count
• void * buffer

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevdBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnSsyevdBatched_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, const int batch_count, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevdBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnDsyevdBatched_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, const int batch_count, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevdBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnCheevdBatched_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, const int batch_count, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevdBatched_bufferSize

musolverStatus_t MUSOLVERAPI musolverDnZheevdBatched_bufferSize(const mublasEvect evect, const mublasFillMode_t uplo, const int n, const int batch_count, size_t *buffersize)

Parameters:

• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• const int batch_count
• size_t * buffersize

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevj

musolverStatus_t MUSOLVERAPI musolverDnSsyevj(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *A, const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, int *info)

SYEVJ computes the eigenvalues and optionally the eigenvectors of a real symmetric matrix A.

The eigenvalues are found using the iterative Jacobi algorithm and are returned in an order depending on the value of esort. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

At the formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]}-th iteration (or "sweep"), formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]} is transformed by a product of Jacobi rotations formula {"type":"element","name":"formula","attributes":{"id":"95"},"children":[{"type":"text","text":"$V$"}]} as

formula {"type":"element","name":"formula","attributes":{"id":"96"},"children":[{"type":"text","text":"\\[\n A^{(k)} = V' A^{(k-1)} V\n \\]"}]}

such that formula {"type":"element","name":"formula","attributes":{"id":"97"},"children":[{"type":"text","text":"$off(A^{(k)}) < off(A^{(k-1)})$"}]}, where formula {"type":"element","name":"formula","attributes":{"id":"98"},"children":[{"type":"text","text":"$A^{(0)} = A$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"99"},"children":[{"type":"text","text":"$off(A^{(k)})$"}]} is the Frobenius norm of the off-diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"100"},"children":[{"type":"text","text":"$A^{(k)}$"}]}. As formula {"type":"element","name":"formula","attributes":{"id":"101"},"children":[{"type":"text","text":"$off(A^{(k)}) \\rightarrow 0$"}]}, the diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"100"},"children":[{"type":"text","text":"$A^{(k)}$"}]} increasingly resemble the eigenvalues of formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]}.

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• esort: mublasEsort.
  Specifies the order of the returned eigenvalues. If esort is MUBLAS_ESORT_ASCENDING, then the eigenvalues are sorted and returned in ascending order. If esort is MUBLAS_ESORT_NONE, then the order of the returned eigenvalues is unspecified.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the eigenvectors of A if they were computed and the algorithm converged; otherwise the contents of A are unchanged.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• abstol: type.
  The absolute tolerance. The algorithm is considered to have converged once off(A) is <= norm(A) * abstol. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to type on the GPU.
  The Frobenius norm of the off-diagonal elements of A (i.e. off(A)) at the final iteration.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to a int on the GPU.
  The actual number of sweeps (iterations) used by the algorithm.
• W: pointer to type. Array on the GPU of dimension n.
  The eigenvalues of A in increasing order.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = 1, the algorithm did not converge.

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevj

musolverStatus_t MUSOLVERAPI musolverDnDsyevj(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *A, const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevj

musolverStatus_t MUSOLVERAPI musolverDnCheevj(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, int *info)

HEEVJ computes the eigenvalues and optionally the eigenvectors of a complex Hermitian matrix A.

The eigenvalues are found using the iterative Jacobi algorithm and are returned in an order depending on the value of esort. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

At the formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]}-th iteration (or "sweep"), formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]} is transformed by a product of Jacobi rotations formula {"type":"element","name":"formula","attributes":{"id":"95"},"children":[{"type":"text","text":"$V$"}]} as

formula {"type":"element","name":"formula","attributes":{"id":"96"},"children":[{"type":"text","text":"\\[\n A^{(k)} = V' A^{(k-1)} V\n \\]"}]}

such that formula {"type":"element","name":"formula","attributes":{"id":"97"},"children":[{"type":"text","text":"$off(A^{(k)}) < off(A^{(k-1)})$"}]}, where formula {"type":"element","name":"formula","attributes":{"id":"98"},"children":[{"type":"text","text":"$A^{(0)} = A$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"99"},"children":[{"type":"text","text":"$off(A^{(k)})$"}]} is the Frobenius norm of the off-diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"100"},"children":[{"type":"text","text":"$A^{(k)}$"}]}. As formula {"type":"element","name":"formula","attributes":{"id":"101"},"children":[{"type":"text","text":"$off(A^{(k)}) \\rightarrow 0$"}]}, the diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"100"},"children":[{"type":"text","text":"$A^{(k)}$"}]} increasingly resemble the eigenvalues of formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]}.

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• esort: mublasEsort.
  Specifies the order of the returned eigenvalues. If esort is MUBLAS_ESORT_ASCENDING, then the eigenvalues are sorted and returned in ascending order. If esort is MUBLAS_ESORT_NONE, then the order of the returned eigenvalues is unspecified.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the Hermitian matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the eigenvectors of A if they were computed and the algorithm converged; otherwise the contents of A are unchanged.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• abstol: real type.
  The absolute tolerance. The algorithm is considered to have converged once off(A) is <= norm(A) * abstol. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to real type on the GPU.
  The Frobenius norm of the off-diagonal elements of A (i.e. off(A)) at the final iteration.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to a int on the GPU.
  The actual number of sweeps (iterations) used by the algorithm.
• W: pointer to real type. Array on the GPU of dimension n.
  The eigenvalues of A in increasing order.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = 1, the algorithm did not converge.

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevj

musolverStatus_t MUSOLVERAPI musolverDnZheevj(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevjBatched

musolverStatus_t MUSOLVERAPI musolverDnSsyevjBatched(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, const int strideW, int *info, const int batch_count)

SYEVJ_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of real symmetric matrices A_j.

The eigenvalues are found using the iterative Jacobi algorithm and are returned in an order depending on the value of esort. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

At the formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]}-th iteration (or "sweep"), formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is transformed by a product of Jacobi rotations formula {"type":"element","name":"formula","attributes":{"id":"79"},"children":[{"type":"text","text":"$V_j$"}]} as

formula {"type":"element","name":"formula","attributes":{"id":"102"},"children":[{"type":"text","text":"\\[\n A_j^{(k)} = V_j' A_j^{(k-1)} V_j\n \\]"}]}

such that formula {"type":"element","name":"formula","attributes":{"id":"103"},"children":[{"type":"text","text":"$off(A_j^{(k)}) < off(A_j^{(k-1)})$"}]}, where formula {"type":"element","name":"formula","attributes":{"id":"104"},"children":[{"type":"text","text":"$A_j^{(0)} =\nA_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"105"},"children":[{"type":"text","text":"$off(A_j^{(k)})$"}]} is the Frobenius norm of the off-diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"106"},"children":[{"type":"text","text":"$A_j^{(k)}$"}]}. As formula {"type":"element","name":"formula","attributes":{"id":"107"},"children":[{"type":"text","text":"$off(A_j^{(k)}) \\rightarrow 0$"}]}, the diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"106"},"children":[{"type":"text","text":"$A_j^{(k)}$"}]} increasingly resemble the eigenvalues of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}.

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• esort: mublasEsort.
  Specifies the order of the returned eigenvalues. If esort is MUBLAS_ESORT_ASCENDING, then the eigenvalues are sorted and returned in ascending order. If esort is MUBLAS_ESORT_NONE, then the order of the returned eigenvalues is unspecified.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and the algorithm converged; otherwise the contents of A_j are unchanged.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• abstol: type.
  The absolute tolerance. The algorithm is considered to have converged once off(A_j) is <= norm(A_j) * abstol. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to type. Array of batch_count scalars on the GPU.
  The Frobenius norm of the off-diagonal elements of A_j (i.e. off(A_j)) at the final iteration.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to int. Array of batch_count integers on the GPU.
  The actual number of sweeps (iterations) used by the algorithm for each batch instance.
• W: pointer to type. Array on the GPU (the size depends on the value of strideW).
  The eigenvalues of A_j in increasing order.
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use case is strideW >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = 1, the algorithm did not converge.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevjBatched

musolverStatus_t MUSOLVERAPI musolverDnDsyevjBatched(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, const int strideW, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevjBatched

musolverStatus_t MUSOLVERAPI musolverDnCheevjBatched(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, const int strideW, int *info, const int batch_count)

HEEVJ_BATCHED computes the eigenvalues and optionally the eigenvectors of a batch of complex Hermitian matrices A_j.

The eigenvalues are found using the iterative Jacobi algorithm and are returned in an order depending on the value of esort. The eigenvectors are computed depending on the value of evect. The computed eigenvectors are orthonormal.

At the formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]}-th iteration (or "sweep"), formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} is transformed by a product of Jacobi rotations formula {"type":"element","name":"formula","attributes":{"id":"79"},"children":[{"type":"text","text":"$V_j$"}]} as

formula {"type":"element","name":"formula","attributes":{"id":"102"},"children":[{"type":"text","text":"\\[\n A_j^{(k)} = V_j' A_j^{(k-1)} V_j\n \\]"}]}

such that formula {"type":"element","name":"formula","attributes":{"id":"103"},"children":[{"type":"text","text":"$off(A_j^{(k)}) < off(A_j^{(k-1)})$"}]}, where formula {"type":"element","name":"formula","attributes":{"id":"104"},"children":[{"type":"text","text":"$A_j^{(0)} =\nA_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"105"},"children":[{"type":"text","text":"$off(A_j^{(k)})$"}]} is the Frobenius norm of the off-diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"106"},"children":[{"type":"text","text":"$A_j^{(k)}$"}]}. As formula {"type":"element","name":"formula","attributes":{"id":"107"},"children":[{"type":"text","text":"$off(A_j^{(k)}) \\rightarrow 0$"}]}, the diagonal elements of formula {"type":"element","name":"formula","attributes":{"id":"106"},"children":[{"type":"text","text":"$A_j^{(k)}$"}]} increasingly resemble the eigenvalues of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}.

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• esort: mublasEsort.
  Specifies the order of the returned eigenvalues. If esort is MUBLAS_ESORT_ASCENDING, then the eigenvalues are sorted and returned in ascending order. If esort is MUBLAS_ESORT_NONE, then the order of the returned eigenvalues is unspecified.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the Hermitian matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the eigenvectors of A_j if they were computed and the algorithm converged; otherwise the contents of A_j are unchanged.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• abstol: real type.
  The absolute tolerance. The algorithm is considered to have converged once off(A_j) is <= norm(A_j) * abstol. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to real type. Array of batch_count scalars on the GPU.
  The Frobenius norm of the off-diagonal elements of A_j (i.e. off(A_j)) at the final iteration.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to int. Array of batch_count integers on the GPU.
  The actual number of sweeps (iterations) used by the algorithm for each batch instance.
• W: pointer to real type. Array on the GPU (the size depends on the value of strideW).
  The eigenvalues of A_j in increasing order.
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use case is strideW >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = 1, the algorithm did not converge.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevjBatched

musolverStatus_t MUSOLVERAPI musolverDnZheevjBatched(musolverDnHandle_t handle, const mublasEsort esort, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, const int strideW, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEsort esort
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevx

musolverStatus_t MUSOLVERAPI musolverDnSsyevx(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, float *A, const int lda, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, float *Z, const int ldz, int *ifail, int *info)

SYEVX computes a set of the eigenvalues and optionally the corresponding eigenvectors of a real symmetric matrix A.

This function computes all the eigenvalues of A, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• vl: type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to a int on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev = n. If erange is MUBLAS_ERANGE_INDEX, nev = iu - il
• 1. Otherwise, 0 <= nev <= n.
• W: pointer to type. Array on the GPU of dimension n.
  The first nev elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• Z: pointer to type. Array on the GPU of dimension ldz*nev.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev columns contain the eigenvectors of A corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev are not known in advance. The user should ensure that Z is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrix Z.
• ifail: pointer to int. Array on the GPU of dimension n.
  If info = 0, the first nev elements of ifail are zero. Otherwise, contains the indices of those eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, the algorithm did not converge. i columns of Z did not converge.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• float * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevx

musolverStatus_t MUSOLVERAPI musolverDnDsyevx(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, double *A, const int lda, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, double *Z, const int ldz, int *ifail, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• double * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevx

musolverStatus_t MUSOLVERAPI musolverDnCheevx(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, muComplex *Z, const int ldz, int *ifail, int *info)

HEEVX computes a set of the eigenvalues and optionally the corresponding eigenvectors of a Hermitian matrix A.

This function computes all the eigenvalues of A, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  Number of rows and columns of matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• vl: real type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: real type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: real type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to a int on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev = n. If erange is MUBLAS_ERANGE_INDEX, nev = iu - il
• 1. Otherwise, 0 <= nev <= n.
• W: pointer to real type. Array on the GPU of dimension n.
  The first nev elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• Z: pointer to type. Array on the GPU of dimension ldz*nev.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev columns contain the eigenvectors of A corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev are not known in advance. The user should ensure that Z is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrix Z.
• ifail: pointer to int. Array on the GPU of dimension n.
  If info = 0, the first nev elements of ifail are zero. Otherwise, contains the indices of those eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, the algorithm did not converge. i columns of Z did not converge.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• muComplex * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevx

musolverStatus_t MUSOLVERAPI musolverDnZheevx(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, muDoubleComplex *Z, const int ldz, int *ifail, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• muDoubleComplex * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsyevxBatched

musolverStatus_t MUSOLVERAPI musolverDnSsyevxBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, const int strideW, float *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

SYEVX_BATCHED computes a set of the eigenvalues and optionally the corresponding eigenvectors of a batch of real symmetric matrices A_j.

This function computes all the eigenvalues of A_j, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• vl: type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to int. Array of batch_count integers on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev_j = n. If erange is MUBLAS_ERANGE_INDEX, nev_j = iu - il + 1. Otherwise, 0 <= nev_j <= n.
• W: pointer to type. Array on the GPU (the size depends on the value of strideW).
  The first nev_j elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use case is strideW >= n.
• Z: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldz*nev_j.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev_j columns contain the eigenvectors of A_j corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev_j are not known in advance. The user should ensure that Z_j is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrices Z_j.
• ifail: pointer to int. Array on the GPU (the size depends on the value of strideF).
  If info[j] = 0, the first nev_j elements of ifail_j are zero. Otherwise, contains the indices of those eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• strideF: int.
  Stride from the start of one vector ifail_j to the next one ifail_(j+1). There is no restriction for the value of strideF. Normal use case is strideF >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge. i columns of Z_j did not converge.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• const int strideW
• float *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsyevxBatched

musolverStatus_t MUSOLVERAPI musolverDnDsyevxBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, const int strideW, double *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• const int strideW
• double *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCheevxBatched

musolverStatus_t MUSOLVERAPI musolverDnCheevxBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, const int strideW, muComplex *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

HEEVX_BATCHED computes a set of the eigenvalues and optionally the corresponding eigenvectors of a batch of Hermitian matrices A_j.

This function computes all the eigenvalues of A_j, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the symmetric matrices A_j is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  Number of rows and columns of matrices A_j.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• vl: real type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: real type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: real type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to int. Array of batch_count integers on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev_j = n. If erange is MUBLAS_ERANGE_INDEX, nev_j = iu - il + 1. Otherwise, 0 <= nev_j <= n.
• W: pointer to real type. Array on the GPU (the size depends on the value of strideW).
  The first nev_j elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use case is strideW >= n.
• Z: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldz*nev_j.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev_j columns contain the eigenvectors of A_j corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev_j are not known in advance. The user should ensure that Z_j is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrices Z_j.
• ifail: pointer to int. Array on the GPU (the size depends on the value of strideF).
  If info[j] = 0, the first nev_j elements of ifail_j are zero. Otherwise, contains the indices of those eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• strideF: int.
  Stride from the start of one vector ifail_j to the next one ifail_(j+1). There is no restriction for the value of strideF. Normal use case is strideF >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for matrix A_j. If info[j] = i > 0, the algorithm did not converge. i columns of Z_j did not converge.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• const int strideW
• muComplex *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZheevxBatched

musolverStatus_t MUSOLVERAPI musolverDnZheevxBatched(musolverDnHandle_t handle, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, const int strideW, muDoubleComplex *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• const int strideW
• muDoubleComplex *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygv

musolverStatus_t MUSOLVERAPI musolverDnSsygv(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *B, const int ldb, float *D, float *E, int *info)

SYGV computes the eigenvalues and (optionally) eigenvectors of a real generalized symmetric-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"109"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^T B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^T B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the symmetric matrix A. On exit, if evect is original, the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular part of the matrix A (including the diagonal) is destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• D: pointer to type. Array on the GPU of dimension n.
  On exit, the eigenvalues in increasing order.
• E: pointer to type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with the reduced eigenvalue problem. On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i <= n, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * B
• const int ldb
• float * D
• float * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygv

musolverStatus_t MUSOLVERAPI musolverDnDsygv(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *B, const int ldb, double *D, double *E, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * B
• const int ldb
• double * D
• double * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegv

musolverStatus_t MUSOLVERAPI musolverDnChegv(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, muComplex *B, const int ldb, float *D, float *E, int *info)

HEGV computes the eigenvalues and (optionally) eigenvectors of a complex generalized hermitian-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"110"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^H B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^H B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the hermitian matrix A. On exit, if evect is original, the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular part of the matrix A (including the diagonal) is destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• D: pointer to real type. Array on the GPU of dimension n.
  On exit, the eigenvalues in increasing order.
• E: pointer to real type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with the reduced eigenvalue problem. On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i <= n, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• muComplex * B
• const int ldb
• float * D
• float * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegv

musolverStatus_t MUSOLVERAPI musolverDnZhegv(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, muDoubleComplex *B, const int ldb, double *D, double *E, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• muDoubleComplex * B
• const int ldb
• double * D
• double * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygvBatched

musolverStatus_t MUSOLVERAPI musolverDnSsygvBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, float *const B[], const int ldb, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count)

SYGV_BATCHED computes the eigenvalues and (optionally) eigenvectors of a batch of real generalized symmetric-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"113"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^T B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^T B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the symmetric matrices A_j. On exit, if evect is original, the normalized matrix Z_j of eigenvectors. If evect is none, then the upper or lower triangular part of the matrices A_j (including the diagonal) are destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• B: array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• D: pointer to type. Array on the GPU (the size depends on the value of strideD).
  On exit, the eigenvalues in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use is strideD >= n.
• E: pointer to type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with the jth reduced eigenvalue problem. On exit, if 0 < info[j] <= n, E_j contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch instance j. If info[j] = i <= n, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• float *const B
• const int ldb
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygvBatched

musolverStatus_t MUSOLVERAPI musolverDnDsygvBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, double *const B[], const int ldb, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• double *const B
• const int ldb
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegvBatched

musolverStatus_t MUSOLVERAPI musolverDnChegvBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, muComplex *const B[], const int ldb, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count)

HEGV_BATCHED computes the eigenvalues and (optionally) eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"114"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^H B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^H B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the hermitian matrices A_j. On exit, if evect is original, the normalized matrix Z_j of eigenvectors. If evect is none, then the upper or lower triangular part of the matrices A_j (including the diagonal) are destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• B: array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• D: pointer to real type. Array on the GPU (the size depends on the value of strideD).
  On exit, the eigenvalues in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use is strideD >= n.
• E: pointer to real type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with the jth reduced eigenvalue problem. On exit, if 0 < info[j] <= n, it contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch j. If info[j] = i <= n, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• muComplex *const B
• const int ldb
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegvBatched

musolverStatus_t MUSOLVERAPI musolverDnZhegvBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, muDoubleComplex *const B[], const int ldb, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• muDoubleComplex *const B
• const int ldb
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygvd

musolverStatus_t MUSOLVERAPI musolverDnSsygvd(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *B, const int ldb, float *D, float *E, int *info)

SYGVD computes the eigenvalues and (optionally) eigenvectors of a real generalized symmetric-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"109"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^T B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^T B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the symmetric matrix A. On exit, if evect is original, the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular part of the matrix A (including the diagonal) is destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• D: pointer to type. Array on the GPU of dimension n.
  On exit, the eigenvalues in increasing order.
• E: pointer to type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with the reduced eigenvalue problem. On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i <= n and evect is MUBLAS_EVECT_NONE, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info = i <= n and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)]. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * B
• const int ldb
• float * D
• float * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygvd

musolverStatus_t MUSOLVERAPI musolverDnDsygvd(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *B, const int ldb, double *D, double *E, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * B
• const int ldb
• double * D
• double * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegvd

musolverStatus_t MUSOLVERAPI musolverDnChegvd(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, muComplex *B, const int ldb, float *D, float *E, int *info)

HEGVD computes the eigenvalues and (optionally) eigenvectors of a complex generalized hermitian-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"110"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^H B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^H B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the hermitian matrix A. On exit, if evect is original, the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular part of the matrix A (including the diagonal) is destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• D: pointer to real type. Array on the GPU of dimension n.
  On exit, the eigenvalues in increasing order.
• E: pointer to real type. Array on the GPU of dimension n.
  This array is used to work internally with the tridiagonal matrix T associated with the reduced eigenvalue problem. On exit, if 0 < info <= n, it contains the unconverged off-diagonal elements of T (or properly speaking, a tridiagonal matrix equivalent to T). The diagonal elements of this matrix are in D; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i <= n and evect is MUBLAS_EVECT_NONE, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info = i <= n and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)]. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• muComplex * B
• const int ldb
• float * D
• float * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegvd

musolverStatus_t MUSOLVERAPI musolverDnZhegvd(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, muDoubleComplex *B, const int ldb, double *D, double *E, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• muDoubleComplex * B
• const int ldb
• double * D
• double * E
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygvdBatched

musolverStatus_t MUSOLVERAPI musolverDnSsygvdBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, float *const B[], const int ldb, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count)

SYGVD_BATCHED computes the eigenvalues and (optionally) eigenvectors of a batch of real generalized symmetric-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"113"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^T B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^T B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the symmetric matrices A_j. On exit, if evect is original, the normalized matrix Z_j of eigenvectors. If evect is none, then the upper or lower triangular part of the matrices A_j (including the diagonal) are destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• B: array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• D: pointer to type. Array on the GPU (the size depends on the value of strideD).
  On exit, the eigenvalues in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use is strideD >= n.
• E: pointer to type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with the jth reduced eigenvalue problem. On exit, if 0 < info[j] <= n, it contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch j. If info[j] = i <= n and evect is MUBLAS_EVECT_NONE, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info[j] = i <= n and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)]. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• float *const B
• const int ldb
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygvdBatched

musolverStatus_t MUSOLVERAPI musolverDnDsygvdBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, double *const B[], const int ldb, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• double *const B
• const int ldb
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegvdBatched

musolverStatus_t MUSOLVERAPI musolverDnChegvdBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, muComplex *const B[], const int ldb, float *D, const int strideD, float *E, const int strideE, int *info, const int batch_count)

HEGVD_BATCHED computes the eigenvalues and (optionally) eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed using a divide-and-conquer algorithm, depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"114"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^H B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^H B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the hermitian matrices A_j. On exit, if evect is original, the normalized matrix Z_j of eigenvectors. If evect is none, then the upper or lower triangular part of the matrices A_j (including the diagonal) are destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• B: array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• D: pointer to real type. Array on the GPU (the size depends on the value of strideD).
  On exit, the eigenvalues in increasing order.
• strideD: int.
  Stride from the start of one vector D_j to the next one D_(j+1). There is no restriction for the value of strideD. Normal use is strideD >= n.
• E: pointer to real type. Array on the GPU (the size depends on the value of strideE).
  This array is used to work internally with the tridiagonal matrix T_j associated with the jth reduced eigenvalue problem. On exit, if 0 < info[j] <= n, it contains the unconverged off-diagonal elements of T_j (or properly speaking, a tridiagonal matrix equivalent to T_j). The diagonal elements of this matrix are in D_j; those that converged correspond to a subset of the eigenvalues (not necessarily ordered).
• strideE: int.
  Stride from the start of one vector E_j to the next one E_(j+1). There is no restriction for the value of strideE. Normal use is strideE >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch j. If info[j] = i <= n and evect is MUBLAS_EVECT_NONE, i off-diagonal elements of an intermediate tridiagonal form did not converge to zero. If info[j] = i <= n and evect is MUBLAS_EVECT_ORIGINAL, the algorithm failed to compute an eigenvalue in the submatrix from [i/(n+1), i/(n+1)] to [i%(n+1), i%(n+1)]. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• muComplex *const B
• const int ldb
• float * D
• const int strideD
• float * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegvdBatched

musolverStatus_t MUSOLVERAPI musolverDnZhegvdBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, muDoubleComplex *const B[], const int ldb, double *D, const int strideD, double *E, const int strideE, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• muDoubleComplex *const B
• const int ldb
• double * D
• const int strideD
• double * E
• const int strideE
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygvj

musolverStatus_t MUSOLVERAPI musolverDnSsygvj(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *B, const int ldb, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, int *info)

SYGVJ computes the eigenvalues and (optionally) eigenvectors of a real generalized symmetric-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvalues are found using the iterative Jacobi algorithm, and are returned in ascending order. The eigenvectors are computed depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"109"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^T B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^T B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the symmetric matrix A. On exit, if evect is original, the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular part of the matrix A (including the diagonal) is destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• abstol: type.
  The absolute tolerance. The algorithm is considered to have converged once off(T) is <= norm(T) * abstol, where T is the matrix obtained by reduction to standard form. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to type on the GPU.
  The Frobenius norm of the off-diagonal elements of T (i.e. off(T)) at the final iteration, where T is the matrix obtained by reduction to standard form.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to a int on the GPU.
  The actual number of sweeps (iterations) used by the algorithm.
• W: pointer to type. Array on the GPU of dimension n.
  On exit, the eigenvalues in increasing order.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = 1, the algorithm did not converge. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * B
• const int ldb
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygvj

musolverStatus_t MUSOLVERAPI musolverDnDsygvj(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *B, const int ldb, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * B
• const int ldb
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegvj

musolverStatus_t MUSOLVERAPI musolverDnChegvj(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, muComplex *B, const int ldb, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, int *info)

HEGVJ computes the eigenvalues and (optionally) eigenvectors of a complex generalized hermitian-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvalues are found using the iterative Jacobi algorithm, and are returned in ascending order. The eigenvectors are computed depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"110"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^H B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^H B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the hermitian matrix A. On exit, if evect is original, the normalized matrix Z of eigenvectors. If evect is none, then the upper or lower triangular part of the matrix A (including the diagonal) is destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• abstol: type.
  The absolute tolerance. The algorithm is considered to have converged once off(T) is <= norm(T) * abstol, where T is the matrix obtained by reduction to standard form. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to type on the GPU.
  The Frobenius norm of the off-diagonal elements of T (i.e. off(T)) at the final iteration, where T is the matrix obtained by reduction to standard form.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to a int on the GPU.
  The actual number of sweeps (iterations) used by the algorithm.
• W: pointer to real type. Array on the GPU of dimension n.
  On exit, the eigenvalues in increasing order.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = 1, the algorithm did not converge. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• muComplex * B
• const int ldb
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegvj

musolverStatus_t MUSOLVERAPI musolverDnZhegvj(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, muDoubleComplex *B, const int ldb, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• muDoubleComplex * B
• const int ldb
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygvjBatched

musolverStatus_t MUSOLVERAPI musolverDnSsygvjBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, float *const B[], const int ldb, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, const int strideW, int *info, const int batch_count)

SYGVJ_BATCHED computes the eigenvalues and (optionally) eigenvectors of a batch of real generalized symmetric-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvalues are found using the iterative Jacobi algorithm, and are returned in ascending order. The eigenvectors are computed depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"113"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^T B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^T B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the symmetric matrices A_j. On exit, if evect is original, the normalized matrix Z_j of eigenvectors. If evect is none, then the upper or lower triangular part of the matrices A_j (including the diagonal) are destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• B: array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• abstol: type.
  The absolute tolerance. The algorithm is considered to have converged once off(T_j) is <= norm(T_j) * abstol, where T_j is the matrix obtained by reduction to standard form. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to type on the GPU.
  The Frobenius norm of the off-diagonal elements of T_j (i.e. off(T_j)) at the final iteration, where T is the matrix obtained by reduction to standard form.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to int. Array of batch_count integers on the GPU.
  The actual number of sweeps (iterations) used by the algorithm for each batch instance.
• W: pointer to type. Array on the GPU (the size depends on the value of strideW).
  On exit, the eigenvalues in increasing order.
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use is strideW >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch instance j. If info[j] = 1, the algorithm did not converge. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• float *const B
• const int ldb
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygvjBatched

musolverStatus_t MUSOLVERAPI musolverDnDsygvjBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, double *const B[], const int ldb, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, const int strideW, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• double *const B
• const int ldb
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegvjBatched

musolverStatus_t MUSOLVERAPI musolverDnChegvjBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, muComplex *const B[], const int ldb, const float abstol, float *residual, const int max_sweeps, int *n_sweeps, float *W, const int strideW, int *info, const int batch_count)

HEGVJ_BATCHED computes the eigenvalues and (optionally) eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvalues are found using the iterative Jacobi algorithm, and are returned in ascending order. The eigenvectors are computed depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"114"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^H B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^H B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

注意：In order to carry out calculations, this method may synchronize the stream contained within the musolverDnHandle_t .

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the hermitian matrices A_j. On exit, if evect is original, the normalized matrix Z_j of eigenvectors. If evect is none, then the upper or lower triangular part of the matrices A_j (including the diagonal) are destroyed, depending on the value of uplo.
• lda: int. lda >= n.
  Specifies the leading dimension of A_j.
• B: array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• abstol: type.
  The absolute tolerance. The algorithm is considered to have converged once off(T_j) is <= norm(T_j) * abstol, where T_j is the matrix obtained by reduction to standard form. If abstol <= 0, then the tolerance will be set to machine precision.
• residual: pointer to type on the GPU.
  The Frobenius norm of the off-diagonal elements of T_j (i.e. off(T_j)) at the final iteration, where T is the matrix obtained by reduction to standard form.
• max_sweeps: int. max_sweeps > 0.
  Maximum number of sweeps (iterations) to be used by the algorithm.
• n_sweeps: pointer to int. Array of batch_count integers on the GPU.
  The actual number of sweeps (iterations) used by the algorithm for each batch instance.
• W: pointer to real type. Array on the GPU (the size depends on the value of strideW).
  On exit, the eigenvalues in increasing order.
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use is strideW >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch j. If info[j] = 1, the algorithm did not converge. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• muComplex *const B
• const int ldb
• const float abstol
• float * residual
• const int max_sweeps
• int * n_sweeps
• float * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegvjBatched

musolverStatus_t MUSOLVERAPI musolverDnZhegvjBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, muDoubleComplex *const B[], const int ldb, const double abstol, double *residual, const int max_sweeps, int *n_sweeps, double *W, const int strideW, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• muDoubleComplex *const B
• const int ldb
• const double abstol
• double * residual
• const int max_sweeps
• int * n_sweeps
• double * W
• const int strideW
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygvx

musolverStatus_t MUSOLVERAPI musolverDnSsygvx(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, float *A, const int lda, float *B, const int ldb, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, float *Z, const int ldz, int *ifail, int *info)

SYGVX computes a set of the eigenvalues and optionally the corresponding eigenvectors of a real generalized symmetric-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"109"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^T B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^T B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

This function computes all the eigenvalues of A, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• vl: type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to a int on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev = n. If erange is MUBLAS_ERANGE_INDEX, nev = iu - il
• 1. Otherwise, 0 <= nev <= n.
• W: pointer to type. Array on the GPU of dimension n.
  The first nev elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• Z: pointer to type. Array on the GPU of dimension ldz*nev.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev columns contain the eigenvectors of A corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev are not known in advance. The user should ensure that Z is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrix Z.
• ifail: pointer to int. Array on the GPU of dimension n.
  If info = 0, the first nev elements of ifail are zero. If info = i <= n, ifail contains the indices of the i eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i <= n, i columns of Z did not converge. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• float * B
• const int ldb
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• float * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygvx

musolverStatus_t MUSOLVERAPI musolverDnDsygvx(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, double *A, const int lda, double *B, const int ldb, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, double *Z, const int ldz, int *ifail, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• double * B
• const int ldb
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• double * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegvx

musolverStatus_t MUSOLVERAPI musolverDnChegvx(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, muComplex *B, const int ldb, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, muComplex *Z, const int ldz, int *ifail, int *info)

HEGVX computes a set of the eigenvalues and optionally the corresponding eigenvectors of a complex generalized hermitian-definite eigenproblem.

The problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"108"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A X = \\lambda B X & \\: \\text{1st form,}\\\\\n A B X = \\lambda X & \\: \\text{2nd form, or}\\\\\n B A X = \\lambda X & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix Z of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"110"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z^H B Z=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z^H B^{-1} Z=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

This function computes all the eigenvalues of A, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblem.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A and B are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A and B are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the matrix A. On exit, the contents of A are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrix A.
• B: pointer to type. Array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrix B. On exit, the triangular factor of B as returned by POTRF.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B.
• vl: real type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: real type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: real type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to a int on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev = n. If erange is MUBLAS_ERANGE_INDEX, nev = iu - il
• 1. Otherwise, 0 <= nev <= n.
• W: pointer to real type. Array on the GPU of dimension n.
  The first nev elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• Z: pointer to type. Array on the GPU of dimension ldz*nev.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev columns contain the eigenvectors of A corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev are not known in advance. The user should ensure that Z is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrix Z.
• ifail: pointer to int. Array on the GPU of dimension n.
  If info = 0, the first nev elements of ifail are zero. If info = i <= n, ifail contains the indices of the i eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i <= n, i columns of Z did not converge. If info = n + i, the leading minor of order i of B is not positive definite.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• muComplex * B
• const int ldb
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• muComplex * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegvx

musolverStatus_t MUSOLVERAPI musolverDnZhegvx(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, muDoubleComplex *B, const int ldb, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, muDoubleComplex *Z, const int ldz, int *ifail, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• muDoubleComplex * B
• const int ldb
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• muDoubleComplex * Z
• const int ldz
• int * ifail
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsygvxBatched

musolverStatus_t MUSOLVERAPI musolverDnSsygvxBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, float *const B[], const int ldb, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, const int strideW, float *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

SYGVX_BATCHED computes a set of the eigenvalues and optionally the corresponding eigenvectors of a batch of real generalized symmetric-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"113"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^T B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^T B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

This function computes all the eigenvalues of A, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• B: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the symmetric positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• vl: type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to int. Array of batch_count integers on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev_j = n. If erange is MUBLAS_ERANGE_INDEX, nev_j = iu - il + 1. Otherwise, 0 <= nev_j <= n.
• W: pointer to type. Array on the GPU (the size depends on the value of strideW).
  The first nev_j elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use case is strideW >= n.
• Z: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldz*nev_j.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev_j columns contain the eigenvectors of A_j corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev_j are not known in advance. The user should ensure that Z_j is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrices Z_j.
• ifail: pointer to int. Array on the GPU (the size depends on the value of strideF).
  If info[j] = 0, the first nev_j elements of ifail_j are zero. If info[j] = i <= n, ifail_j contains the indices of the i eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• strideF: int.
  Stride from the start of one vector ifail_j to the next one ifail_(j+1). There is no restriction for the value of strideF. Normal use case is strideF >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch instance j. If info[j] = i <= n, i columns of Z did not converge. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• float *const B
• const int ldb
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• const int strideW
• float *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsygvxBatched

musolverStatus_t MUSOLVERAPI musolverDnDsygvxBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, double *const B[], const int ldb, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, const int strideW, double *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• double *const B
• const int ldb
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• const int strideW
• double *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnChegvxBatched

musolverStatus_t MUSOLVERAPI musolverDnChegvxBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, muComplex *const B[], const int ldb, const float vl, const float vu, const int il, const int iu, const float abstol, int *nev, float *W, const int strideW, muComplex *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

HEGVX_BATCHED computes a set of the eigenvalues and optionally the corresponding eigenvectors of a batch of complex generalized hermitian-definite eigenproblems.

For each instance in the batch, the problem solved by this function is either of the form

formula {"type":"element","name":"formula","attributes":{"id":"111"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j X_j = \\lambda B_j X_j & \\: \\text{1st form,}\\\\\n A_j B_j X_j = \\lambda X_j & \\: \\text{2nd form, or}\\\\\n B_j A_j X_j = \\lambda X_j & \\: \\text{3rd form,}\n \\end{array}\n \\]"}]}

depending on the value of itype. The eigenvectors are computed depending on the value of evect.

When computed, the matrix formula {"type":"element","name":"formula","attributes":{"id":"112"},"children":[{"type":"text","text":"$Z_j$"}]} of eigenvectors is normalized as follows:

formula {"type":"element","name":"formula","attributes":{"id":"114"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n Z_j^H B_j Z_j=I & \\: \\text{if 1st or 2nd form, or}\\\\\n Z_j^H B_j^{-1} Z_j=I & \\: \\text{if 3rd form.}\n \\end{array}\n \\]"}]}

This function computes all the eigenvalues of A, all the eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]}, or the il-th through iu-th eigenvalues, depending on the value of erange. If evect is MUBLAS_EVECT_ORIGINAL, the eigenvectors for these eigenvalues will be computed as well.

Parameters:

• handle: musolverDnHandle_t .
• itype: mublasEform.
  Specifies the form of the generalized eigenproblems.
• evect: mublasEvect.
  Specifies whether the eigenvectors are to be computed. If evect is MUBLAS_EVECT_ORIGINAL, then the eigenvectors are computed. MUBLAS_EVECT_TRIDIAGONAL is not supported.
• erange: mublasErange.
  Specifies the type of range or interval of the eigenvalues to be computed.
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower parts of the matrices A_j and B_j are stored. If uplo indicates lower (or upper), then the upper (or lower) parts of A_j and B_j are not used.
• n: int. n >= 0.
  The matrix dimensions.
• A: Array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the matrices A_j. On exit, the contents of A_j are destroyed.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• B: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldb*n.
  On entry, the hermitian positive definite matrices B_j. On exit, the triangular factor of B_j as returned by POTRF_BATCHED.
• ldb: int. ldb >= n.
  Specifies the leading dimension of B_j.
• vl: real type. vl < vu.
  The lower bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• vu: real type. vl < vu.
  The upper bound of the search interval (vl, vu]. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues within a set of indices.
• il: int. il = 1 if n = 0; 1 <= il <= iu otherwise.
  The index of the smallest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of A or the eigenvalues in a half-open interval.
• iu: int. iu = 0 if n = 0; 1 <= il <= iu otherwise..
  The index of the largest eigenvalue to be computed. Ignored if range indicates to look for all the eigenvalues of T or the eigenvalues in a half-open interval.
• abstol: real type.
  The absolute tolerance. An eigenvalue is considered to be located if it lies in an interval whose width is <= abstol. If abstol is negative, then machine-epsilon times the 1-norm of T will be used as tolerance. If abstol=0, then the tolerance will be set to twice the underflow threshold; this is the tolerance that could get the most accurate results.
• nev: pointer to int. Array of batch_count integers on the GPU.
  The total number of eigenvalues found. If erange is MUBLAS_ERANGE_ALL, nev_j = n. If erange is MUBLAS_ERANGE_INDEX, nev_j = iu - il + 1. Otherwise, 0 <= nev_j <= n.
• W: pointer to real type. Array on the GPU (the size depends on the value of strideW).
  The first nev_j elements contain the computed eigenvalues. (The remaining elements can be used as workspace for internal computations).
• strideW: int.
  Stride from the start of one vector W_j to the next one W_(j+1). There is no restriction for the value of strideW. Normal use case is strideW >= n.
• Z: Array of pointers to type. Each pointer points to an array on the GPU of dimension ldz*nev_j.
  On exit, if evect is not MUBLAS_EVECT_NONE and info = 0, the first nev_j columns contain the eigenvectors of A_j corresponding to the output eigenvalues. Not referenced if evect is MUBLAS_EVECT_NONE. Note: If erange is mublas_range_value, then the values of nev_j are not known in advance. The user should ensure that Z_j is large enough to hold n columns, as all n columns can be used as workspace for internal computations.
• ldz: int. ldz >= n.
  Specifies the leading dimension of matrices Z_j.
• ifail: pointer to int. Array on the GPU (the size depends on the value of strideF).
  If info[j] = 0, the first nev_j elements of ifail_j are zero. If info[j] = i <= n, ifail_j contains the indices of the i eigenvectors that failed to converge. Not referenced if evect is MUBLAS_EVECT_NONE.
• strideF: int.
  Stride from the start of one vector ifail_j to the next one ifail_(j+1). There is no restriction for the value of strideF. Normal use case is strideF >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit of batch instance j. If info[j] = i <= n, i columns of Z did not converge. If info[j] = n + i, the leading minor of order i of B_j is not positive definite.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• muComplex *const B
• const int ldb
• const float vl
• const float vu
• const int il
• const int iu
• const float abstol
• int * nev
• float * W
• const int strideW
• muComplex *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZhegvxBatched

musolverStatus_t MUSOLVERAPI musolverDnZhegvxBatched(musolverDnHandle_t handle, const mublasEform itype, const mublasEvect evect, const mublasErange erange, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, muDoubleComplex *const B[], const int ldb, const double vl, const double vu, const int il, const int iu, const double abstol, int *nev, double *W, const int strideW, muDoubleComplex *const Z[], const int ldz, int *ifail, const int strideF, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasEform itype
• const mublasEvect evect
• const mublasErange erange
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• muDoubleComplex *const B
• const int ldb
• const double vl
• const double vu
• const int il
• const int iu
• const double abstol
• int * nev
• double * W
• const int strideW
• muDoubleComplex *const Z
• const int ldz
• int * ifail
• const int strideF
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnStrtri

musolverStatus_t MUSOLVERAPI musolverDnStrtri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, float *A, const int lda, int *info)

TRTRI inverts a triangular n-by-n matrix A.

A can be upper or lower triangular, depending on the value of uplo, and unit or non-unit triangular, depending on the value of diag.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• diag: mublasDiagType_t.
  If diag indicates unit, then the diagonal elements of A are not referenced and assumed to be one.
• n: int. n >= 0.
  The number of rows and columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the triangular matrix. On exit, the inverse of A if info = 0.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, A is singular. A[i,i] is the first zero element in the diagonal.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• float * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDtrtri

musolverStatus_t MUSOLVERAPI musolverDnDtrtri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, double *A, const int lda, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• double * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCtrtri

musolverStatus_t MUSOLVERAPI musolverDnCtrtri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, muComplex *A, const int lda, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• muComplex * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZtrtri

musolverStatus_t MUSOLVERAPI musolverDnZtrtri(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, muDoubleComplex *A, const int lda, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• muDoubleComplex * A
• const int lda
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnStrtriBatched

musolverStatus_t MUSOLVERAPI musolverDnStrtriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, float *const A[], const int lda, int *info, const int batch_count)

TRTRI_BATCHED inverts a batch of triangular n-by-n matrices formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}.

formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]} can be upper or lower triangular, depending on the value of uplo, and unit or non-unit triangular, depending on the value of diag.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the matrices A_j are stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• diag: mublasDiagType_t.
  If diag indicates unit, then the diagonal elements of matrices A_j are not referenced and assumed to be one.
• n: int. n >= 0.
  The number of rows and columns of all matrices A_j in the batch.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the triangular matrices A_j. On exit, the inverses of A_j if info[j] = 0.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for inversion of A_j. If info[j] = i > 0, A_j is singular. A_j[i,i] is the first zero element in the diagonal.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• float *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDtrtriBatched

musolverStatus_t MUSOLVERAPI musolverDnDtrtriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, double *const A[], const int lda, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• double *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCtrtriBatched

musolverStatus_t MUSOLVERAPI musolverDnCtrtriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, muComplex *const A[], const int lda, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• muComplex *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZtrtriBatched

musolverStatus_t MUSOLVERAPI musolverDnZtrtriBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const mublasDiagType_t diag, const int n, muDoubleComplex *const A[], const int lda, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const mublasDiagType_t diag
• const int n
• muDoubleComplex *const A
• const int lda
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsytrf

musolverStatus_t MUSOLVERAPI musolverDnSsytrf(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, float *A, const int lda, int *ipiv, int *info)

SYTRF computes the factorization of a symmetric indefinite matrix formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]} using Bunch-Kaufman diagonal pivoting.

(This is the blocked version of the algorithm).

The factorization has the form

formula {"type":"element","name":"formula","attributes":{"id":"115"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A = U D U^T & \\: \\text{or}\\\\\n A = L D L^T &\n \\end{array}\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"73"},"children":[{"type":"text","text":"$U$"}]} or formula {"type":"element","name":"formula","attributes":{"id":"74"},"children":[{"type":"text","text":"$L$"}]} is a product of permutation and unit upper/lower triangular matrices (depending on the value of uplo), and formula {"type":"element","name":"formula","attributes":{"id":"116"},"children":[{"type":"text","text":"$D$"}]} is a symmetric block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks formula {"type":"element","name":"formula","attributes":{"id":"117"},"children":[{"type":"text","text":"$D(k)$"}]}.

Specifically, formula {"type":"element","name":"formula","attributes":{"id":"73"},"children":[{"type":"text","text":"$U$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"74"},"children":[{"type":"text","text":"$L$"}]} are computed as

formula {"type":"element","name":"formula","attributes":{"id":"118"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n U = P(n) U(n) \\cdots P(k) U(k) \\cdots & \\: \\text{and}\\\\\n L = P(1) L(1) \\cdots P(k) L(k) \\cdots &\n \\end{array}\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} decreases from formula {"type":"element","name":"formula","attributes":{"id":"119"},"children":[{"type":"text","text":"$n$"}]} to 1 (increases from 1 to formula {"type":"element","name":"formula","attributes":{"id":"119"},"children":[{"type":"text","text":"$n$"}]}) in steps of 1 or 2, depending on the order of block formula {"type":"element","name":"formula","attributes":{"id":"117"},"children":[{"type":"text","text":"$D(k)$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"120"},"children":[{"type":"text","text":"$P(k)$"}]} is a permutation matrix defined by formula {"type":"element","name":"formula","attributes":{"id":"121"},"children":[{"type":"text","text":"$ipiv[k]$"}]}. If we let formula {"type":"element","name":"formula","attributes":{"id":"122"},"children":[{"type":"text","text":"$s$"}]} denote the order of block formula {"type":"element","name":"formula","attributes":{"id":"117"},"children":[{"type":"text","text":"$D(k)$"}]}, then formula {"type":"element","name":"formula","attributes":{"id":"123"},"children":[{"type":"text","text":"$U(k)$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"124"},"children":[{"type":"text","text":"$L(k)$"}]} are unit upper/lower triangular matrices defined as

formula {"type":"element","name":"formula","attributes":{"id":"125"},"children":[{"type":"text","text":"\\[\n U(k) = \\left[ \\begin{array}{ccc}\n I_{k-s} & v & 0 \\\\\n 0 & I_s & 0 \\\\\n 0 & 0 & I_{n-k}\n \\end{array} \\right]\n \\]"}]}

and

formula {"type":"element","name":"formula","attributes":{"id":"126"},"children":[{"type":"text","text":"\\[\n L(k) = \\left[ \\begin{array}{ccc}\n I_{k-1} & 0 & 0 \\\\\n 0 & I_s & 0 \\\\\n 0 & v & I_{n-k-s+1}\n \\end{array} \\right].\n \\]"}]}

If formula {"type":"element","name":"formula","attributes":{"id":"127"},"children":[{"type":"text","text":"$s = 1$"}]}, then formula {"type":"element","name":"formula","attributes":{"id":"117"},"children":[{"type":"text","text":"$D(k)$"}]} is stored in formula {"type":"element","name":"formula","attributes":{"id":"128"},"children":[{"type":"text","text":"$A[k,k]$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"129"},"children":[{"type":"text","text":"$v$"}]} is stored in the upper/lower part of column formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} of formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]}. If formula {"type":"element","name":"formula","attributes":{"id":"130"},"children":[{"type":"text","text":"$s = 2$"}]} and uplo is upper, then formula {"type":"element","name":"formula","attributes":{"id":"117"},"children":[{"type":"text","text":"$D(k)$"}]} is stored in formula {"type":"element","name":"formula","attributes":{"id":"131"},"children":[{"type":"text","text":"$A[k-1,k-1]$"}]}, formula {"type":"element","name":"formula","attributes":{"id":"132"},"children":[{"type":"text","text":"$A[k-1,k]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"128"},"children":[{"type":"text","text":"$A[k,k]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"129"},"children":[{"type":"text","text":"$v$"}]} is stored in the upper parts of columns formula {"type":"element","name":"formula","attributes":{"id":"133"},"children":[{"type":"text","text":"$k-1$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} of formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]}. If formula {"type":"element","name":"formula","attributes":{"id":"130"},"children":[{"type":"text","text":"$s = 2$"}]} and uplo is lower, then formula {"type":"element","name":"formula","attributes":{"id":"117"},"children":[{"type":"text","text":"$D(k)$"}]} is stored in formula {"type":"element","name":"formula","attributes":{"id":"128"},"children":[{"type":"text","text":"$A[k,k]$"}]}, formula {"type":"element","name":"formula","attributes":{"id":"134"},"children":[{"type":"text","text":"$A[k+1,k]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"135"},"children":[{"type":"text","text":"$A[k+1,k+1]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"129"},"children":[{"type":"text","text":"$v$"}]} is stored in the lower parts of columns formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"136"},"children":[{"type":"text","text":"$k+1$"}]} of formula {"type":"element","name":"formula","attributes":{"id":"71"},"children":[{"type":"text","text":"$A$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the matrix A is stored. If uplo indicates lower (or upper), then the upper (or lower) part of A is not used.
• n: int. n >= 0.
  The number of rows and columns of the matrix A.
• A: pointer to type. Array on the GPU of dimension lda*n.
  On entry, the symmetric matrix A to be factored. On exit, the block diagonal matrix D and the multipliers needed to compute U or L.
• lda: int. lda >= n.
  Specifies the leading dimension of A.
• ipiv: pointer to int. Array on the GPU of dimension n.
  The vector of pivot indices. Elements of ipiv are 1-based indices. For 1 <= k <= n, if ipiv[k] > 0 then rows and columns k and ipiv[k] were interchanged and D[k,k] is a 1-by-1 diagonal block. If, instead, ipiv[k] = ipiv[k-1] < 0 and uplo is upper (or ipiv[k] = ipiv[k+1] < 0 and uplo is lower), then rows and columns k-1 and -ipiv[k] (or rows and columns k+1 and -ipiv[k]) were interchanged and D[k-1,k-1] to D[k,k] (or D[k,k] to D[k+1,k+1]) is a 2-by-2 diagonal block.
• info: pointer to a int on the GPU.
  If info = 0, successful exit. If info = i > 0, D is singular. D[i,i] is the first diagonal zero.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• float * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsytrf

musolverStatus_t MUSOLVERAPI musolverDnDsytrf(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, double *A, const int lda, int *ipiv, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• double * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCsytrf

musolverStatus_t MUSOLVERAPI musolverDnCsytrf(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muComplex *A, const int lda, int *ipiv, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muComplex * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZsytrf

musolverStatus_t MUSOLVERAPI musolverDnZsytrf(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muDoubleComplex *A, const int lda, int *ipiv, int *info)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex * A
• const int lda
• int * ipiv
• int * info

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSsytrfBatched

musolverStatus_t MUSOLVERAPI musolverDnSsytrfBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, float *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

SYTRF_BATCHED computes the factorization of a batch of symmetric indefinite matrices using Bunch-Kaufman diagonal pivoting.

(This is the blocked version of the algorithm).

The factorization has the form

formula {"type":"element","name":"formula","attributes":{"id":"137"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n A_j = U_j D_j U_j^T & \\: \\text{or}\\\\\n A_j = L_j D_j L_j^T &\n \\end{array}\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} or formula {"type":"element","name":"formula","attributes":{"id":"26"},"children":[{"type":"text","text":"$L_j$"}]} is a product of permutation and unit upper/lower triangular matrices (depending on the value of uplo), and formula {"type":"element","name":"formula","attributes":{"id":"138"},"children":[{"type":"text","text":"$D_j$"}]} is a symmetric block diagonal matrix with 1-by-1 and 2-by-2 diagonal blocks formula {"type":"element","name":"formula","attributes":{"id":"139"},"children":[{"type":"text","text":"$D_j(k)$"}]}.

Specifically, formula {"type":"element","name":"formula","attributes":{"id":"27"},"children":[{"type":"text","text":"$U_j$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"26"},"children":[{"type":"text","text":"$L_j$"}]} are computed as

formula {"type":"element","name":"formula","attributes":{"id":"140"},"children":[{"type":"text","text":"\\[\n \\begin{array}{cl}\n U_j = P_j(n) U_j(n) \\cdots P_j(k) U_j(k) \\cdots & \\: \\text{and}\\\\\n L_j = P_j(1) L_j(1) \\cdots P_j(k) L_j(k) \\cdots &\n \\end{array}\n \\]"}]}

where formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} decreases from formula {"type":"element","name":"formula","attributes":{"id":"119"},"children":[{"type":"text","text":"$n$"}]} to 1 (increases from 1 to formula {"type":"element","name":"formula","attributes":{"id":"119"},"children":[{"type":"text","text":"$n$"}]}) in steps of 1 or 2, depending on the order of block formula {"type":"element","name":"formula","attributes":{"id":"139"},"children":[{"type":"text","text":"$D_j(k)$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"141"},"children":[{"type":"text","text":"$P_j(k)$"}]} is a permutation matrix defined by formula {"type":"element","name":"formula","attributes":{"id":"142"},"children":[{"type":"text","text":"$ipiv_j[k]$"}]}. If we let formula {"type":"element","name":"formula","attributes":{"id":"122"},"children":[{"type":"text","text":"$s$"}]} denote the order of block formula {"type":"element","name":"formula","attributes":{"id":"139"},"children":[{"type":"text","text":"$D_j(k)$"}]}, then formula {"type":"element","name":"formula","attributes":{"id":"143"},"children":[{"type":"text","text":"$U_j(k)$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"144"},"children":[{"type":"text","text":"$L_j(k)$"}]} are unit upper/lower triangular matrices defined as

formula {"type":"element","name":"formula","attributes":{"id":"145"},"children":[{"type":"text","text":"\\[\n U_j(k) = \\left[ \\begin{array}{ccc}\n I_{k-s} & v & 0 \\\\\n 0 & I_s & 0 \\\\\n 0 & 0 & I_{n-k}\n \\end{array} \\right]\n \\]"}]}

and

formula {"type":"element","name":"formula","attributes":{"id":"146"},"children":[{"type":"text","text":"\\[\n L_j(k) = \\left[ \\begin{array}{ccc}\n I_{k-1} & 0 & 0 \\\\\n 0 & I_s & 0 \\\\\n 0 & v & I_{n-k-s+1}\n \\end{array} \\right].\n \\]"}]}

If formula {"type":"element","name":"formula","attributes":{"id":"127"},"children":[{"type":"text","text":"$s = 1$"}]}, then formula {"type":"element","name":"formula","attributes":{"id":"139"},"children":[{"type":"text","text":"$D_j(k)$"}]} is stored in formula {"type":"element","name":"formula","attributes":{"id":"147"},"children":[{"type":"text","text":"$A_j[k,k]$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"129"},"children":[{"type":"text","text":"$v$"}]} is stored in the upper/lower part of column formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}. If formula {"type":"element","name":"formula","attributes":{"id":"130"},"children":[{"type":"text","text":"$s = 2$"}]} and uplo is upper, then formula {"type":"element","name":"formula","attributes":{"id":"139"},"children":[{"type":"text","text":"$D_j(k)$"}]} is stored in formula {"type":"element","name":"formula","attributes":{"id":"148"},"children":[{"type":"text","text":"$A_j[k-1,k-1]$"}]}, formula {"type":"element","name":"formula","attributes":{"id":"149"},"children":[{"type":"text","text":"$A_j[k-1,k]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"147"},"children":[{"type":"text","text":"$A_j[k,k]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"129"},"children":[{"type":"text","text":"$v$"}]} is stored in the upper parts of columns formula {"type":"element","name":"formula","attributes":{"id":"133"},"children":[{"type":"text","text":"$k-1$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}. If formula {"type":"element","name":"formula","attributes":{"id":"130"},"children":[{"type":"text","text":"$s = 2$"}]} and uplo is lower, then formula {"type":"element","name":"formula","attributes":{"id":"139"},"children":[{"type":"text","text":"$D_j(k)$"}]} is stored in formula {"type":"element","name":"formula","attributes":{"id":"147"},"children":[{"type":"text","text":"$A_j[k,k]$"}]}, formula {"type":"element","name":"formula","attributes":{"id":"150"},"children":[{"type":"text","text":"$A_j[k+1,k]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"151"},"children":[{"type":"text","text":"$A_j[k+1,k+1]$"}]}, and formula {"type":"element","name":"formula","attributes":{"id":"129"},"children":[{"type":"text","text":"$v$"}]} is stored in the lower parts of columns formula {"type":"element","name":"formula","attributes":{"id":"94"},"children":[{"type":"text","text":"$k$"}]} and formula {"type":"element","name":"formula","attributes":{"id":"136"},"children":[{"type":"text","text":"$k+1$"}]} of formula {"type":"element","name":"formula","attributes":{"id":"23"},"children":[{"type":"text","text":"$A_j$"}]}.

Parameters:

• handle: musolverDnHandle_t .
• uplo: mublasFillMode_t .
  Specifies whether the upper or lower part of the matrices A_j are stored. If uplo indicates lower (or upper), then the upper (or lower) part of A_j is not used.
• n: int. n >= 0.
  The number of rows and columns of all matrices A_j in the batch.
• A: array of pointers to type. Each pointer points to an array on the GPU of dimension lda*n.
  On entry, the symmetric matrices A_j to be factored. On exit, the block diagonal matrices D_j and the multipliers needed to compute U_j or L_j.
• lda: int. lda >= n.
  Specifies the leading dimension of matrices A_j.
• ipiv: pointer to int. Array on the GPU of dimension n.
  The vector of pivot indices. Elements of ipiv are 1-based indices. For 1 <= k <= n, if ipiv_j[k] > 0 then rows and columns k and ipiv_j[k] were interchanged and D_j[k,k] is a 1-by-1 diagonal block. If, instead, ipiv_j[k] = ipiv_j[k-1] < 0 and uplo is upper (or ipiv_j[k] = ipiv_j[k+1] < 0 and uplo is lower), then rows and columns k-1 and -ipiv_j[k] (or rows and columns k+1 and -ipiv_j[k]) were interchanged and D_j[k-1,k-1] to D_j[k,k] (or D_j[k,k] to D_j[k+1,k+1]) is a 2-by-2 diagonal block.
• strideP: int.
  Stride from the start of one vector ipiv_j to the next one ipiv_(j+1). There is no restriction for the value of strideP. Normal use case is strideP >= n.
• info: pointer to int. Array of batch_count integers on the GPU.
  If info[j] = 0, successful exit for factorization of A_j. If info[j] = i > 0, D_j is singular. D_j[i,i] is the first diagonal zero.
• batch_count: int. batch_count >= 0.
  Number of matrices in the batch.

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• float *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDsytrfBatched

musolverStatus_t MUSOLVERAPI musolverDnDsytrfBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, double *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• double *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCsytrfBatched

musolverStatus_t MUSOLVERAPI musolverDnCsytrfBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muComplex *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muComplex *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnZsytrfBatched

musolverStatus_t MUSOLVERAPI musolverDnZsytrfBatched(musolverDnHandle_t handle, const mublasFillMode_t uplo, const int n, muDoubleComplex *const A[], const int lda, int *ipiv, const int strideP, int *info, const int batch_count)

Parameters:

• musolverDnHandle_t handle
• const mublasFillMode_t uplo
• const int n
• muDoubleComplex *const A
• const int lda
• int * ipiv
• const int strideP
• int * info
• const int batch_count

Return type: musolverStatus_t MUSOLVERAPI

Functions

Function musolverDnCreate

musolverStatus_t MUSOLVERAPI musolverDnCreate(musolverDnHandle_t *handle)

Parameters:

• musolverDnHandle_t * handle

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDestroy

musolverStatus_t MUSOLVERAPI musolverDnDestroy(musolverDnHandle_t handle)

Parameters:

• musolverDnHandle_t handle

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnSetStream

musolverStatus_t MUSOLVERAPI musolverDnSetStream(musolverDnHandle_t handle, musaStream_t stream)

Parameters:

• musolverDnHandle_t handle
• musaStream_t stream

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnGetStream

musolverStatus_t MUSOLVERAPI musolverDnGetStream(musolverDnHandle_t handle, musaStream_t *stream)

Parameters:

• musolverDnHandle_t handle
• musaStream_t * stream

Return type: musolverStatus_t MUSOLVERAPI

Function musolverGetVersionString

musolverStatus_t MUSOLVERAPI musolverGetVersionString(char *buf, size_t len)

GET_VERSION_STRING Queries the library version.

Parameters:

• buf: A buffer that the version string will be written into.
• len: The size of the given buffer in bytes.

Parameters:

• char * buf
• size_t len

Return type: musolverStatus_t MUSOLVERAPI

Function musolverGetVersionStringSize

musolverStatus_t MUSOLVERAPI musolverGetVersionStringSize(size_t *len)

GET_VERSION_STRING_SIZE Queries the minimum buffer size for a successful call to musolverGetVersionString.

Parameters:

• len: pointer to size_t.
  The minimum length of buffer to pass to musolverGetVersionString.

Parameters:

• size_t * len

Return type: musolverStatus_t MUSOLVERAPI

Function musolverLogBegin

musolverStatus_t MUSOLVERAPI musolverLogBegin(void)

LOG_BEGIN begins a muSOLVER multi-level logging session.

Initializes the muSOLVER logging environment with default values (no logging and one level depth). Default mode can be overridden by using the environment variables MUSOLVER_LAYER and MUSOLVER_LEVELS.

This function also sets the streams where the log results will be outputted. The default is STDERR for all the modes. This default can also be overridden using the environment variable MUSOLVER_LOG_PATH, or specifically MUSOLVER_LOG_TRACE_PATH, MUSOLVER_LOG_BENCH_PATH, and/or MUSOLVER_LOG_PROFILE_PATH.

Parameters:

• void

Return type: musolverStatus_t MUSOLVERAPI

Function musolverLogEnd

musolverStatus_t MUSOLVERAPI musolverLogEnd(void)

LOG_END ends the multi-level muSOLVER logging session.

If applicable, this function also prints the profile logging results before cleaning the logging environment.

Parameters:

• void

Return type: musolverStatus_t MUSOLVERAPI

Function musolverLogSetLayerMode

musolverStatus_t MUSOLVERAPI musolverLogSetLayerMode(const mublasLayerModeFlags layer_mode)

LOG_SET_LAYER_MODE sets the logging mode for the muSOLVER multi-level logging environment.

Parameters:

• layer_mode: mublasLayerModeFlags.
  Specifies the logging mode.

Parameters:

• const mublasLayerModeFlags layer_mode

Return type: musolverStatus_t MUSOLVERAPI

Function musolverLogSetMaxLevels

musolverStatus_t MUSOLVERAPI musolverLogSetMaxLevels(const int max_levels)

LOG_SET_MAX_LEVELS sets the maximum trace log depth for the muSOLVER multi-level logging environment.

Parameters:

• max_levels: int. max_levels >= 1.
  Specifies the maximum depth at which nested function calls will appear in the trace and profile logs.

Parameters:

• const int max_levels

Return type: musolverStatus_t MUSOLVERAPI

Function musolverLogRestoreDefaults

musolverStatus_t MUSOLVERAPI musolverLogRestoreDefaults(void)

LOG_RESTORE_DEFAULTS restores the default values of the muSOLVER multi-level logging environment.

This function sets the logging mode and maximum trace log depth to their default values (no logging and one level depth).

Parameters:

• void

Return type: musolverStatus_t MUSOLVERAPI

Function musolverLogWriteProfile

musolverStatus_t MUSOLVERAPI musolverLogWriteProfile(void)

LOG_WRITE_PROFILE prints the profile logging results.

Parameters:

• void

Return type: musolverStatus_t MUSOLVERAPI

Function musolverLogFlushProfile

musolverStatus_t MUSOLVERAPI musolverLogFlushProfile(void)

LOG_FLUSH_PROFILE prints the profile logging results and clears the profile record.

Parameters:

• void

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnCreateRfinfo

musolverStatus_t MUSOLVERAPI musolverDnCreateRfinfo(musolverRfinfo *rfinfo, musolverDnHandle_t handle)

CREATE_RFINFO initializes the structure rfinfo, required by the re-factorization functions CSRRF_REFACTLU and CSRRF_SOLVE, that contains the meta data and descriptors of the involved matrices.

Parameters:

• rfinfo: musolverRfinfo.
  The pointer to the rfinfo struct to be initialized.
• handle: musolverDnHandle_t .
  

Parameters:

• musolverRfinfo * rfinfo
• musolverDnHandle_t handle

Return type: musolverStatus_t MUSOLVERAPI

Function musolverDnDestroyRfinfo

musolverStatus_t MUSOLVERAPI musolverDnDestroyRfinfo(musolverRfinfo rfinfo)

DESTROY_RFINFO destroys the structure rfinfo used by the re-factorization functions CSRRF_REFACTLU and CSRRF_SOLVE.

Parameters:

• rfinfo: musolverRfinfo.
  The rfinfo struct to be destroyed.

Parameters:

• musolverRfinfo rfinfo

Return type: musolverStatus_t MUSOLVERAPI

---

File musolverMg.h

Location: musolverMg.h

Includes

• <cstdint>
• musolverDn.h
• musolver_common.h

Included by

• musolver.h

Macros

Enumeration types

Enumeration type musolverMgGridMapping_t

Definition: musolverMg.h (line 25)

enum musolverMgGridMapping_t {
 MUSALIBMG_GRID_MAPPING_ROW_MAJOR = 1,
 MUSALIBMG_GRID_MAPPING_COL_MAJOR = 0
}

\beief This enum decides how 1D device Ids (or process ranks) get mapped to a 2D grid.

Enumerator MUSALIBMG_GRID_MAPPING_ROW_MAJOR

Enumerator MUSALIBMG_GRID_MAPPING_COL_MAJOR

Typedefs

Typedef musolverMgHandle_t

Definition: musolverMg.h (line 19)

typedef struct musolverMgContext* musolverMgHandle_t

Return type: struct musolverMgContext *

Typedef musaLibMgGrid_t

Definition: musolverMg.h (line 31)

typedef void* musaLibMgGrid_t

Opaque structure of the distributed grid.

Return type: void *

Typedef musaLibMgMatrixDesc_t

Definition: musolverMg.h (line 33)

typedef void* musaLibMgMatrixDesc_t

Opaque structure of the distributed matrix descriptor.

Return type: void *

Functions

Function musolverMgCreate

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgCreate(musolverMgHandle_t *handle)

Parameters:

• musolverMgHandle_t * handle

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgDestroy

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgDestroy(musolverMgHandle_t handle)

Parameters:

• musolverMgHandle_t handle

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgDeviceSelect

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgDeviceSelect(musolverMgHandle_t handle, int nbDevices, int deviceId[])

Parameters:

• musolverMgHandle_t handle
• int nbDevices
• int deviceId

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgCreateDeviceGrid

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgCreateDeviceGrid(musaLibMgGrid_t *grid, int32_t numRowDevices, int32_t numColDevices, const int32_t deviceId[], musolverMgGridMapping_t mapping)

Allocates resources related to the shared memory device grid.

Parameters:

• grid: the opaque data strcuture that holds the grid
• numRowDevices: number of devices in the row
• numColDevices: number of devices in the column
• deviceId: This array of size height * width stores the device-ids of the 2D grid; each entry must correspond to a valid gpu or to -1 (denoting CPU).
• mapping: whether the 2D grid is in row/column major

Returns:

the status code

Parameters:

• musaLibMgGrid_t * grid
• int32_t numRowDevices
• int32_t numColDevices
• const int32_t deviceId
• musolverMgGridMapping_t mapping

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgDestroyGrid

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgDestroyGrid(musaLibMgGrid_t grid)

Releases the allocated resources related to the distributed grid.

Parameters:

• grid: the opaque data strcuture that holds the distributed grid

Returns:

the status code

Parameters:

• musaLibMgGrid_t grid

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgCreateMatrixDesc

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgCreateMatrixDesc(musaLibMgMatrixDesc_t *desc, int64_t numRows, int64_t numCols, int64_t rowBlockSize, int64_t colBlockSize, musaDataType dataType, const musaLibMgGrid_t grid)

Allocates resources related to the distributed matrix descriptor.

Parameters:

• desc: the opaque data strcuture that holds the descriptor
• numRows: number of total rows
• numCols: number of total columns
• rowBlockSize: row block size
• colBlockSize: column block size
• dataType: the data type of each element in musaDataType
• grid: the opaque data structure of the distributed grid

Returns:

the status code

Parameters:

• musaLibMgMatrixDesc_t * desc
• int64_t numRows
• int64_t numCols
• int64_t rowBlockSize
• int64_t colBlockSize
• musaDataType dataType
• const musaLibMgGrid_t grid

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgDestroyMatrixDesc

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgDestroyMatrixDesc(musaLibMgMatrixDesc_t desc)

Releases the allocated resources related to the distributed matrix descriptor.

Parameters:

• desc: the opaque data strcuture that holds the descriptor

Returns:

the status code

Parameters:

• musaLibMgMatrixDesc_t desc

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgSyevd_bufferSize

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgSyevd_bufferSize(musolverMgHandle_t handle, musolverEigMode_t jobz, mublasFillMode_t uplo, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, void *W, musaDataType dataTypeW, musaDataType computeType, int64_t *lwork)

Parameters:

• musolverMgHandle_t handle
• musolverEigMode_t jobz
• mublasFillMode_t uplo
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• void * W
• musaDataType dataTypeW
• musaDataType computeType
• int64_t * lwork

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgSyevd

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgSyevd(musolverMgHandle_t handle, musolverEigMode_t jobz, mublasFillMode_t uplo, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, void *W, musaDataType dataTypeW, musaDataType computeType, void *array_d_work[], int64_t lwork, int *info)

Parameters:

• musolverMgHandle_t handle
• musolverEigMode_t jobz
• mublasFillMode_t uplo
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• void * W
• musaDataType dataTypeW
• musaDataType computeType
• void * array_d_work
• int64_t lwork
• int * info

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgGetrf_bufferSize

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgGetrf_bufferSize(musolverMgHandle_t handle, int M, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, int *array_d_IPIV[], musaDataType computeType, int64_t *lwork)

Parameters:

• musolverMgHandle_t handle
• int M
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• int * array_d_IPIV
• musaDataType computeType
• int64_t * lwork

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgGetrf

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgGetrf(musolverMgHandle_t handle, int M, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, int *array_d_IPIV[], musaDataType computeType, void *array_d_work[], int64_t lwork, int *info)

Parameters:

• musolverMgHandle_t handle
• int M
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• int * array_d_IPIV
• musaDataType computeType
• void * array_d_work
• int64_t lwork
• int * info

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgGetrs_bufferSize

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgGetrs_bufferSize(musolverMgHandle_t handle, mublasOperation_t TRANS, int N, int NRHS, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, int *array_d_IPIV[], void *array_d_B[], int IB, int JB, musaLibMgMatrixDesc_t descrB, musaDataType computeType, int64_t *lwork)

Parameters:

• musolverMgHandle_t handle
• mublasOperation_t TRANS
• int N
• int NRHS
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• int * array_d_IPIV
• void * array_d_B
• int IB
• int JB
• musaLibMgMatrixDesc_t descrB
• musaDataType computeType
• int64_t * lwork

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgGetrs

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgGetrs(musolverMgHandle_t handle, mublasOperation_t TRANS, int N, int NRHS, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, int *array_d_IPIV[], void *array_d_B[], int IB, int JB, musaLibMgMatrixDesc_t descrB, musaDataType computeType, void *array_d_work[], int64_t lwork, int *info)

Parameters:

• musolverMgHandle_t handle
• mublasOperation_t TRANS
• int N
• int NRHS
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• int * array_d_IPIV
• void * array_d_B
• int IB
• int JB
• musaLibMgMatrixDesc_t descrB
• musaDataType computeType
• void * array_d_work
• int64_t lwork
• int * info

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgPotrf_bufferSize

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgPotrf_bufferSize(musolverMgHandle_t handle, mublasFillMode_t uplo, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, musaDataType computeType, int64_t *lwork)

Parameters:

• musolverMgHandle_t handle
• mublasFillMode_t uplo
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• musaDataType computeType
• int64_t * lwork

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgPotrf

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgPotrf(musolverMgHandle_t handle, mublasFillMode_t uplo, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, musaDataType computeType, void *array_d_work[], int64_t lwork, int *h_info)

Parameters:

• musolverMgHandle_t handle
• mublasFillMode_t uplo
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• musaDataType computeType
• void * array_d_work
• int64_t lwork
• int * h_info

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgPotrs_bufferSize

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgPotrs_bufferSize(musolverMgHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, void *array_d_B[], int IB, int JB, musaLibMgMatrixDesc_t descrB, musaDataType computeType, int64_t *lwork)

Parameters:

• musolverMgHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• void * array_d_B
• int IB
• int JB
• musaLibMgMatrixDesc_t descrB
• musaDataType computeType
• int64_t * lwork

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgPotrs

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgPotrs(musolverMgHandle_t handle, mublasFillMode_t uplo, int n, int nrhs, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, void *array_d_B[], int IB, int JB, musaLibMgMatrixDesc_t descrB, musaDataType computeType, void *array_d_work[], int64_t lwork, int *h_info)

Parameters:

• musolverMgHandle_t handle
• mublasFillMode_t uplo
• int n
• int nrhs
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• void * array_d_B
• int IB
• int JB
• musaLibMgMatrixDesc_t descrB
• musaDataType computeType
• void * array_d_work
• int64_t lwork
• int * h_info

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgPotri_bufferSize

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgPotri_bufferSize(musolverMgHandle_t handle, mublasFillMode_t uplo, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, musaDataType computeType, int64_t *lwork)

Parameters:

• musolverMgHandle_t handle
• mublasFillMode_t uplo
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• musaDataType computeType
• int64_t * lwork

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

Function musolverMgPotri

MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI musolverMgPotri(musolverMgHandle_t handle, mublasFillMode_t uplo, int N, void *array_d_A[], int IA, int JA, musaLibMgMatrixDesc_t descrA, musaDataType computeType, void *array_d_work[], int64_t lwork, int *h_info)

Parameters:

• musolverMgHandle_t handle
• mublasFillMode_t uplo
• int N
• void * array_d_A
• int IA
• int JA
• musaLibMgMatrixDesc_t descrA
• musaDataType computeType
• void * array_d_work
• int64_t lwork
• int * h_info

Return type: MUSOLVERMG_DEPRECATED musolverStatus_t MUSOLVERAPI

---

File musolverRf.h

Location: musolverRf.h

Includes

• driver_types.h
• muComplex.h
• musolver_common.h

Included by

• musolver.h

Enumeration types

Enumeration type musolverRfResetValuesFastMode_t

Definition: musolverRf.h (line 17)

enum musolverRfResetValuesFastMode_t {
 MUSOLVERRF_RESET_VALUES_FAST_MODE_OFF = 0,
 MUSOLVERRF_RESET_VALUES_FAST_MODE_ON = 1
}

Enumerator MUSOLVERRF_RESET_VALUES_FAST_MODE_OFF

Enumerator MUSOLVERRF_RESET_VALUES_FAST_MODE_ON

Enumeration type musolverRfMatrixFormat_t

Definition: musolverRf.h (line 23)

enum musolverRfMatrixFormat_t {
 MUSOLVERRF_MATRIX_FORMAT_CSR = 0,
 MUSOLVERRF_MATRIX_FORMAT_CSC = 1
}

Enumerator MUSOLVERRF_MATRIX_FORMAT_CSR

Enumerator MUSOLVERRF_MATRIX_FORMAT_CSC

Enumeration type musolverRfUnitDiagonal_t

Definition: musolverRf.h (line 29)

enum musolverRfUnitDiagonal_t {
 MUSOLVERRF_UNIT_DIAGONAL_STORED_L = 0,
 MUSOLVERRF_UNIT_DIAGONAL_STORED_U = 1,
 MUSOLVERRF_UNIT_DIAGONAL_ASSUMED_L = 2,
 MUSOLVERRF_UNIT_DIAGONAL_ASSUMED_U = 3
}

Enumerator MUSOLVERRF_UNIT_DIAGONAL_STORED_L

Enumerator MUSOLVERRF_UNIT_DIAGONAL_STORED_U

Enumerator MUSOLVERRF_UNIT_DIAGONAL_ASSUMED_L

Enumerator MUSOLVERRF_UNIT_DIAGONAL_ASSUMED_U

Enumeration type musolverRfFactorization_t

Definition: musolverRf.h (line 37)

enum musolverRfFactorization_t {
 MUSOLVERRF_FACTORIZATION_ALG0 = 0,
 MUSOLVERRF_FACTORIZATION_ALG1 = 1,
 MUSOLVERRF_FACTORIZATION_ALG2 = 2
}

Enumerator MUSOLVERRF_FACTORIZATION_ALG0

Enumerator MUSOLVERRF_FACTORIZATION_ALG1

Enumerator MUSOLVERRF_FACTORIZATION_ALG2

Enumeration type musolverRfTriangularSolve_t

Definition: musolverRf.h (line 44)

enum musolverRfTriangularSolve_t {
 MUSOLVERRF_TRIANGULAR_SOLVE_ALG1 = 1,
 MUSOLVERRF_TRIANGULAR_SOLVE_ALG2 = 2,
 MUSOLVERRF_TRIANGULAR_SOLVE_ALG3 = 3
}

Enumerator MUSOLVERRF_TRIANGULAR_SOLVE_ALG1

Enumerator MUSOLVERRF_TRIANGULAR_SOLVE_ALG2

Enumerator MUSOLVERRF_TRIANGULAR_SOLVE_ALG3

Enumeration type musolverRfNumericBoostReport_t

Definition: musolverRf.h (line 51)

enum musolverRfNumericBoostReport_t {
 MUSOLVERRF_NUMERIC_BOOST_NOT_USED = 0,
 MUSOLVERRF_NUMERIC_BOOST_USED = 1
}

Enumerator MUSOLVERRF_NUMERIC_BOOST_NOT_USED

Enumerator MUSOLVERRF_NUMERIC_BOOST_USED

Typedefs

Typedef musolverRfHandle_t

Definition: musolverRf.h (line 58)

typedef struct musolverRfCommon* musolverRfHandle_t

Return type: struct musolverRfCommon *

Functions

Function musolverRfCreate

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfCreate(musolverRfHandle_t *handle)

Parameters:

• musolverRfHandle_t * handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfDestroy

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfDestroy(musolverRfHandle_t handle)

Parameters:

• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfGetMatrixFormat

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfGetMatrixFormat(musolverRfHandle_t handle, musolverRfMatrixFormat_t *format, musolverRfUnitDiagonal_t *diag)

Parameters:

• musolverRfHandle_t handle
• musolverRfMatrixFormat_t * format
• musolverRfUnitDiagonal_t * diag

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfSetMatrixFormat

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfSetMatrixFormat(musolverRfHandle_t handle, musolverRfMatrixFormat_t format, musolverRfUnitDiagonal_t diag)

Parameters:

• musolverRfHandle_t handle
• musolverRfMatrixFormat_t format
• musolverRfUnitDiagonal_t diag

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfSetNumericProperties

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfSetNumericProperties(musolverRfHandle_t handle, double zero, double boost)

Parameters:

• musolverRfHandle_t handle
• double zero
• double boost

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfGetNumericProperties

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfGetNumericProperties(musolverRfHandle_t handle, double *zero, double *boost)

Parameters:

• musolverRfHandle_t handle
• double * zero
• double * boost

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfGetNumericBoostReport

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfGetNumericBoostReport(musolverRfHandle_t handle, musolverRfNumericBoostReport_t *report)

Parameters:

• musolverRfHandle_t handle
• musolverRfNumericBoostReport_t * report

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfSetAlgs

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfSetAlgs(musolverRfHandle_t handle, musolverRfFactorization_t factAlg, musolverRfTriangularSolve_t solveAlg)

Parameters:

• musolverRfHandle_t handle
• musolverRfFactorization_t factAlg
• musolverRfTriangularSolve_t solveAlg

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfGetAlgs

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfGetAlgs(musolverRfHandle_t handle, musolverRfFactorization_t *factAlg, musolverRfTriangularSolve_t *solveAlg)

Parameters:

• musolverRfHandle_t handle
• musolverRfFactorization_t * factAlg
• musolverRfTriangularSolve_t * solveAlg

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfGetResetValuesFastMode

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfGetResetValuesFastMode(musolverRfHandle_t handle, musolverRfResetValuesFastMode_t *fastMode)

Parameters:

• musolverRfHandle_t handle
• musolverRfResetValuesFastMode_t * fastMode

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfSetResetValuesFastMode

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfSetResetValuesFastMode(musolverRfHandle_t handle, musolverRfResetValuesFastMode_t fastMode)

Parameters:

• musolverRfHandle_t handle
• musolverRfResetValuesFastMode_t fastMode

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfSetupHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfSetupHost(int n, int nnzA, int *h_csrRowPtrA, int *h_csrColIndA, double *h_csrValA, int nnzL, int *h_csrRowPtrL, int *h_csrColIndL, double *h_csrValL, int nnzU, int *h_csrRowPtrU, int *h_csrColIndU, double *h_csrValU, int *h_P, int *h_Q, musolverRfHandle_t handle)

Parameters:

• int n
• int nnzA
• int * h_csrRowPtrA
• int * h_csrColIndA
• double * h_csrValA
• int nnzL
• int * h_csrRowPtrL
• int * h_csrColIndL
• double * h_csrValL
• int nnzU
• int * h_csrRowPtrU
• int * h_csrColIndU
• double * h_csrValU
• int * h_P
• int * h_Q
• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfSetupDevice

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfSetupDevice(int n, int nnzA, int *csrRowPtrA, int *csrColIndA, double *csrValA, int nnzL, int *csrRowPtrL, int *csrColIndL, double *csrValL, int nnzU, int *csrRowPtrU, int *csrColIndU, double *csrValU, int *P, int *Q, musolverRfHandle_t handle)

Parameters:

• int n
• int nnzA
• int * csrRowPtrA
• int * csrColIndA
• double * csrValA
• int nnzL
• int * csrRowPtrL
• int * csrColIndL
• double * csrValL
• int nnzU
• int * csrRowPtrU
• int * csrColIndU
• double * csrValU
• int * P
• int * Q
• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfResetValues

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfResetValues(int n, int nnzA, int *csrRowPtrA, int *csrColIndA, double *csrValA, int *P, int *Q, musolverRfHandle_t handle)

Parameters:

• int n
• int nnzA
• int * csrRowPtrA
• int * csrColIndA
• double * csrValA
• int * P
• int * Q
• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfAnalyze

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfAnalyze(musolverRfHandle_t handle)

Parameters:

• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfRefactor

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfRefactor(musolverRfHandle_t handle)

Parameters:

• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfAccessBundledFactorsDevice

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfAccessBundledFactorsDevice(musolverRfHandle_t handle, int *nnzM, int **Mp, int **Mi, double **Mx)

Parameters:

• musolverRfHandle_t handle
• int * nnzM
• int ** Mp
• int ** Mi
• double ** Mx

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfExtractBundledFactorsHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfExtractBundledFactorsHost(musolverRfHandle_t handle, int *h_nnzM, int **h_Mp, int **h_Mi, double **h_Mx)

Parameters:

• musolverRfHandle_t handle
• int * h_nnzM
• int ** h_Mp
• int ** h_Mi
• double ** h_Mx

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfExtractSplitFactorsHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfExtractSplitFactorsHost(musolverRfHandle_t handle, int *h_nnzL, int **h_csrRowPtrL, int **h_csrColIndL, double **h_csrValL, int *h_nnzU, int **h_csrRowPtrU, int **h_csrColIndU, double **h_csrValU)

Parameters:

• musolverRfHandle_t handle
• int * h_nnzL
• int ** h_csrRowPtrL
• int ** h_csrColIndL
• double ** h_csrValL
• int * h_nnzU
• int ** h_csrRowPtrU
• int ** h_csrColIndU
• double ** h_csrValU

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfSolve

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfSolve(musolverRfHandle_t handle, int *P, int *Q, int nrhs, double *Temp, int ldt, double *XF, int ldxf)

Parameters:

• musolverRfHandle_t handle
• int * P
• int * Q
• int nrhs
• double * Temp
• int ldt
• double * XF
• int ldxf

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfBatchSetupHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfBatchSetupHost(int batchSize, int n, int nnzA, int *h_csrRowPtrA, int *h_csrColIndA, double *h_csrValA_array[], int nnzL, int *h_csrRowPtrL, int *h_csrColIndL, double *h_csrValL, int nnzU, int *h_csrRowPtrU, int *h_csrColIndU, double *h_csrValU, int *h_P, int *h_Q, musolverRfHandle_t handle)

Parameters:

• int batchSize
• int n
• int nnzA
• int * h_csrRowPtrA
• int * h_csrColIndA
• double * h_csrValA_array
• int nnzL
• int * h_csrRowPtrL
• int * h_csrColIndL
• double * h_csrValL
• int nnzU
• int * h_csrRowPtrU
• int * h_csrColIndU
• double * h_csrValU
• int * h_P
• int * h_Q
• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfBatchResetValues

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfBatchResetValues(int batchSize, int n, int nnzA, int *csrRowPtrA, int *csrColIndA, double *csrValA_array[], int *P, int *Q, musolverRfHandle_t handle)

Parameters:

• int batchSize
• int n
• int nnzA
• int * csrRowPtrA
• int * csrColIndA
• double * csrValA_array
• int * P
• int * Q
• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfBatchAnalyze

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfBatchAnalyze(musolverRfHandle_t handle)

Parameters:

• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfBatchRefactor

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfBatchRefactor(musolverRfHandle_t handle)

Parameters:

• musolverRfHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfBatchSolve

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfBatchSolve(musolverRfHandle_t handle, int *P, int *Q, int nrhs, double *Temp, int ldt, double *XF_array[], int ldxf)

Parameters:

• musolverRfHandle_t handle
• int * P
• int * Q
• int nrhs
• double * Temp
• int ldt
• double * XF_array
• int ldxf

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverRfBatchZeroPivot

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverRfBatchZeroPivot(musolverRfHandle_t handle, int *position)

Parameters:

• musolverRfHandle_t handle
• int * position

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

---

File musolverSp.h

Location: musolverSp.h

Includes

• musparse.h
• mublas.h
• musolver_common.h

Included by

• musolver.h

Typedefs

Typedef musolverSpHandle_t

Definition: musolverSp.h (line 17)

typedef struct musolverSpContext* musolverSpHandle_t

Return type: struct musolverSpContext *

Typedef csrqrInfo_t

Definition: musolverSp.h (line 20)

typedef struct csrqrInfo* csrqrInfo_t

Return type: struct csrqrInfo *

Functions

Function musolverSpCreate

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCreate(musolverSpHandle_t *handle)

Parameters:

• musolverSpHandle_t * handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDestroy

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDestroy(musolverSpHandle_t handle)

Parameters:

• musolverSpHandle_t handle

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpSetStream

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpSetStream(musolverSpHandle_t handle, musaStream_t streamId)

Parameters:

• musolverSpHandle_t handle
• musaStream_t streamId

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpGetStream

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpGetStream(musolverSpHandle_t handle, musaStream_t *streamId)

Parameters:

• musolverSpHandle_t handle
• musaStream_t * streamId

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrissymHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrissymHost(musolverSpHandle_t handle, int m, int nnzA, const musparseMatDescr_t descrA, const int *csrRowPtrA, const int *csrEndPtrA, const int *csrColIndA, int *issym)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnzA
• const musparseMatDescr_t descrA
• const int * csrRowPtrA
• const int * csrEndPtrA
• const int * csrColIndA
• int * issym

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrlsvluHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrlsvluHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, const float *b, float tol, int reorder, float *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const float * b
• float tol
• int reorder
• float * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrlsvluHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrlsvluHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, const double *b, double tol, int reorder, double *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const double * b
• double tol
• int reorder
• double * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrlsvluHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrlsvluHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muComplex *b, float tol, int reorder, muComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muComplex * b
• float tol
• int reorder
• muComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrlsvluHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrlsvluHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muDoubleComplex *b, double tol, int reorder, muDoubleComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muDoubleComplex * b
• double tol
• int reorder
• muDoubleComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrlsvqr

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrlsvqr(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const float *csrVal, const int *csrRowPtr, const int *csrColInd, const float *b, float tol, int reorder, float *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const float * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const float * b
• float tol
• int reorder
• float * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrlsvqr

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrlsvqr(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const double *csrVal, const int *csrRowPtr, const int *csrColInd, const double *b, double tol, int reorder, double *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const double * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const double * b
• double tol
• int reorder
• double * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrlsvqr

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrlsvqr(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muComplex *csrVal, const int *csrRowPtr, const int *csrColInd, const muComplex *b, float tol, int reorder, muComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const muComplex * b
• float tol
• int reorder
• muComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrlsvqr

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrlsvqr(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrVal, const int *csrRowPtr, const int *csrColInd, const muDoubleComplex *b, double tol, int reorder, muDoubleComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const muDoubleComplex * b
• double tol
• int reorder
• muDoubleComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrlsvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrlsvqrHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, const float *b, float tol, int reorder, float *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const float * b
• float tol
• int reorder
• float * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrlsvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrlsvqrHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, const double *b, double tol, int reorder, double *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const double * b
• double tol
• int reorder
• double * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrlsvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrlsvqrHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muComplex *b, float tol, int reorder, muComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muComplex * b
• float tol
• int reorder
• muComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrlsvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrlsvqrHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muDoubleComplex *b, double tol, int reorder, muDoubleComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muDoubleComplex * b
• double tol
• int reorder
• muDoubleComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrlsvcholHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrlsvcholHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const float *csrVal, const int *csrRowPtr, const int *csrColInd, const float *b, float tol, int reorder, float *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const float * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const float * b
• float tol
• int reorder
• float * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrlsvcholHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrlsvcholHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const double *csrVal, const int *csrRowPtr, const int *csrColInd, const double *b, double tol, int reorder, double *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const double * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const double * b
• double tol
• int reorder
• double * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrlsvcholHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrlsvcholHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muComplex *csrVal, const int *csrRowPtr, const int *csrColInd, const muComplex *b, float tol, int reorder, muComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const muComplex * b
• float tol
• int reorder
• muComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrlsvcholHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrlsvcholHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrVal, const int *csrRowPtr, const int *csrColInd, const muDoubleComplex *b, double tol, int reorder, muDoubleComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const muDoubleComplex * b
• double tol
• int reorder
• muDoubleComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrlsvchol

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrlsvchol(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const float *csrVal, const int *csrRowPtr, const int *csrColInd, const float *b, float tol, int reorder, float *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const float * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const float * b
• float tol
• int reorder
• float * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrlsvchol

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrlsvchol(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const double *csrVal, const int *csrRowPtr, const int *csrColInd, const double *b, double tol, int reorder, double *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const double * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const double * b
• double tol
• int reorder
• double * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrlsvchol

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrlsvchol(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muComplex *csrVal, const int *csrRowPtr, const int *csrColInd, const muComplex *b, float tol, int reorder, muComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const muComplex * b
• float tol
• int reorder
• muComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrlsvchol

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrlsvchol(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrVal, const int *csrRowPtr, const int *csrColInd, const muDoubleComplex *b, double tol, int reorder, muDoubleComplex *x, int *singularity)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• const muDoubleComplex * b
• double tol
• int reorder
• muDoubleComplex * x
• int * singularity

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrlsqvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrlsqvqrHost(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, const float *b, float tol, int *rankA, float *x, int *p, float *min_norm)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const float * b
• float tol
• int * rankA
• float * x
• int * p
• float * min_norm

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrlsqvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrlsqvqrHost(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, const double *b, double tol, int *rankA, double *x, int *p, double *min_norm)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const double * b
• double tol
• int * rankA
• double * x
• int * p
• double * min_norm

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrlsqvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrlsqvqrHost(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muComplex *b, float tol, int *rankA, muComplex *x, int *p, float *min_norm)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muComplex * b
• float tol
• int * rankA
• muComplex * x
• int * p
• float * min_norm

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrlsqvqrHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrlsqvqrHost(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muDoubleComplex *b, double tol, int *rankA, muDoubleComplex *x, int *p, double *min_norm)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muDoubleComplex * b
• double tol
• int * rankA
• muDoubleComplex * x
• int * p
• double * min_norm

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsreigvsiHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsreigvsiHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, float mu0, const float *x0, int maxite, float tol, float *mu, float *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• float mu0
• const float * x0
• int maxite
• float tol
• float * mu
• float * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsreigvsiHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsreigvsiHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, double mu0, const double *x0, int maxite, double tol, double *mu, double *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• double mu0
• const double * x0
• int maxite
• double tol
• double * mu
• double * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsreigvsiHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsreigvsiHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, muComplex mu0, const muComplex *x0, int maxite, float tol, muComplex *mu, muComplex *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muComplex mu0
• const muComplex * x0
• int maxite
• float tol
• muComplex * mu
• muComplex * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsreigvsiHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsreigvsiHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, muDoubleComplex mu0, const muDoubleComplex *x0, int maxite, double tol, muDoubleComplex *mu, muDoubleComplex *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muDoubleComplex mu0
• const muDoubleComplex * x0
• int maxite
• double tol
• muDoubleComplex * mu
• muDoubleComplex * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsreigvsi

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsreigvsi(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, float mu0, const float *x0, int maxite, float eps, float *mu, float *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• float mu0
• const float * x0
• int maxite
• float eps
• float * mu
• float * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsreigvsi

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsreigvsi(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, double mu0, const double *x0, int maxite, double eps, double *mu, double *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• double mu0
• const double * x0
• int maxite
• double eps
• double * mu
• double * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsreigvsi

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsreigvsi(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, muComplex mu0, const muComplex *x0, int maxite, float eps, muComplex *mu, muComplex *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muComplex mu0
• const muComplex * x0
• int maxite
• float eps
• muComplex * mu
• muComplex * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsreigvsi

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsreigvsi(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, muDoubleComplex mu0, const muDoubleComplex *x0, int maxite, double eps, muDoubleComplex *mu, muDoubleComplex *x)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muDoubleComplex mu0
• const muDoubleComplex * x0
• int maxite
• double eps
• muDoubleComplex * mu
• muDoubleComplex * x

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsreigsHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsreigsHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, muComplex left_bottom_corner, muComplex right_upper_corner, int *num_eigs)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muComplex left_bottom_corner
• muComplex right_upper_corner
• int * num_eigs

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsreigsHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsreigsHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, muDoubleComplex left_bottom_corner, muDoubleComplex right_upper_corner, int *num_eigs)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muDoubleComplex left_bottom_corner
• muDoubleComplex right_upper_corner
• int * num_eigs

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsreigsHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsreigsHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, muComplex left_bottom_corner, muComplex right_upper_corner, int *num_eigs)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muComplex left_bottom_corner
• muComplex right_upper_corner
• int * num_eigs

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsreigsHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsreigsHost(musolverSpHandle_t handle, int m, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, muDoubleComplex left_bottom_corner, muDoubleComplex right_upper_corner, int *num_eigs)

Parameters:

• musolverSpHandle_t handle
• int m
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• muDoubleComplex left_bottom_corner
• muDoubleComplex right_upper_corner
• int * num_eigs

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrsymrcmHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrsymrcmHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const int *csrRowPtrA, const int *csrColIndA, int *p)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const int * csrRowPtrA
• const int * csrColIndA
• int * p

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrsymmdqHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrsymmdqHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const int *csrRowPtrA, const int *csrColIndA, int *p)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const int * csrRowPtrA
• const int * csrColIndA
• int * p

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrsymamdHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrsymamdHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const int *csrRowPtrA, const int *csrColIndA, int *p)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const int * csrRowPtrA
• const int * csrColIndA
• int * p

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrmetisndHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrmetisndHost(musolverSpHandle_t handle, int n, int nnzA, const musparseMatDescr_t descrA, const int *csrRowPtrA, const int *csrColIndA, const int64_t *options, int *p)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const int * csrRowPtrA
• const int * csrColIndA
• const int64_t * options
• int * p

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrzfdHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrzfdHost(musolverSpHandle_t handle, int n, int nnz, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, int *P, int *numnz)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnz
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• int * P
• int * numnz

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrzfdHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrzfdHost(musolverSpHandle_t handle, int n, int nnz, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, int *P, int *numnz)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnz
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• int * P
• int * numnz

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrzfdHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrzfdHost(musolverSpHandle_t handle, int n, int nnz, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, int *P, int *numnz)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• int * P
• int * numnz

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrzfdHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrzfdHost(musolverSpHandle_t handle, int n, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, int *P, int *numnz)

Parameters:

• musolverSpHandle_t handle
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• int * P
• int * numnz

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrperm_bufferSizeHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrperm_bufferSizeHost(musolverSpHandle_t handle, int m, int n, int nnzA, const musparseMatDescr_t descrA, const int *csrRowPtrA, const int *csrColIndA, const int *p, const int *q, size_t *bufferSizeInBytes)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const int * csrRowPtrA
• const int * csrColIndA
• const int * p
• const int * q
• size_t * bufferSizeInBytes

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrpermHost

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrpermHost(musolverSpHandle_t handle, int m, int n, int nnzA, const musparseMatDescr_t descrA, int *csrRowPtrA, int *csrColIndA, const int *p, const int *q, int *map, void *pBuffer)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnzA
• const musparseMatDescr_t descrA
• int * csrRowPtrA
• int * csrColIndA
• const int * p
• const int * q
• int * map
• void * pBuffer

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCreateCsrqrInfo

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCreateCsrqrInfo(csrqrInfo_t *info)

Parameters:

• csrqrInfo_t * info

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDestroyCsrqrInfo

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDestroyCsrqrInfo(csrqrInfo_t info)

Parameters:

• csrqrInfo_t info

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpXcsrqrAnalysisBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpXcsrqrAnalysisBatched(musolverSpHandle_t handle, int m, int n, int nnzA, const musparseMatDescr_t descrA, const int *csrRowPtrA, const int *csrColIndA, csrqrInfo_t info)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnzA
• const musparseMatDescr_t descrA
• const int * csrRowPtrA
• const int * csrColIndA
• csrqrInfo_t info

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrqrBufferInfoBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrqrBufferInfoBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const float *csrVal, const int *csrRowPtr, const int *csrColInd, int batchSize, csrqrInfo_t info, size_t *internalDataInBytes, size_t *workspaceInBytes)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const float * csrVal
• const int * csrRowPtr
• const int * csrColInd
• int batchSize
• csrqrInfo_t info
• size_t * internalDataInBytes
• size_t * workspaceInBytes

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrqrBufferInfoBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrqrBufferInfoBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const double *csrVal, const int *csrRowPtr, const int *csrColInd, int batchSize, csrqrInfo_t info, size_t *internalDataInBytes, size_t *workspaceInBytes)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const double * csrVal
• const int * csrRowPtr
• const int * csrColInd
• int batchSize
• csrqrInfo_t info
• size_t * internalDataInBytes
• size_t * workspaceInBytes

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrqrBufferInfoBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrqrBufferInfoBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const muComplex *csrVal, const int *csrRowPtr, const int *csrColInd, int batchSize, csrqrInfo_t info, size_t *internalDataInBytes, size_t *workspaceInBytes)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• int batchSize
• csrqrInfo_t info
• size_t * internalDataInBytes
• size_t * workspaceInBytes

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrqrBufferInfoBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrqrBufferInfoBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrVal, const int *csrRowPtr, const int *csrColInd, int batchSize, csrqrInfo_t info, size_t *internalDataInBytes, size_t *workspaceInBytes)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrVal
• const int * csrRowPtr
• const int * csrColInd
• int batchSize
• csrqrInfo_t info
• size_t * internalDataInBytes
• size_t * workspaceInBytes

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpScsrqrsvBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpScsrqrsvBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const float *csrValA, const int *csrRowPtrA, const int *csrColIndA, const float *b, float *x, int batchSize, csrqrInfo_t info, void *pBuffer)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const float * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const float * b
• float * x
• int batchSize
• csrqrInfo_t info
• void * pBuffer

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpDcsrqrsvBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpDcsrqrsvBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const double *csrValA, const int *csrRowPtrA, const int *csrColIndA, const double *b, double *x, int batchSize, csrqrInfo_t info, void *pBuffer)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const double * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const double * b
• double * x
• int batchSize
• csrqrInfo_t info
• void * pBuffer

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpCcsrqrsvBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpCcsrqrsvBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const muComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muComplex *b, muComplex *x, int batchSize, csrqrInfo_t info, void *pBuffer)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muComplex * b
• muComplex * x
• int batchSize
• csrqrInfo_t info
• void * pBuffer

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

Function musolverSpZcsrqrsvBatched

MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI musolverSpZcsrqrsvBatched(musolverSpHandle_t handle, int m, int n, int nnz, const musparseMatDescr_t descrA, const muDoubleComplex *csrValA, const int *csrRowPtrA, const int *csrColIndA, const muDoubleComplex *b, muDoubleComplex *x, int batchSize, csrqrInfo_t info, void *pBuffer)

Parameters:

• musolverSpHandle_t handle
• int m
• int n
• int nnz
• const musparseMatDescr_t descrA
• const muDoubleComplex * csrValA
• const int * csrRowPtrA
• const int * csrColIndA
• const muDoubleComplex * b
• muDoubleComplex * x
• int batchSize
• csrqrInfo_t info
• void * pBuffer

Return type: MUSOLVER_DEPRECATED_ musolverStatus_t MUSOLVERAPI

---

File musolver.h

Location: musolver.h

musolver.h includes other *.h and exposes a common interface

Includes

• <musa_runtime.h>
• musolver_common.h
• musolverDn.h
• musolverSp.h
• musolverSp_LOWLEVEL_PREVIEW.h
• musolverRf.h
• musolverMg.h
• musolver_version.h

---

File musolver_common.h

Location: musolver\_common.h

Includes

• <stdint.h>
• mublas.h

Included by

• musolver.h
• musolverDn.h
• musolverMg.h
• musolverRf.h
• musolverSp.h

Macros

Enumeration types

Enumeration type musolverStatus_t

Definition: musolver\_common.h (line 37)

enum musolverStatus_t {
 MUSOLVER_STATUS_SUCCESS = 0,
 MUSOLVER_STATUS_NOT_INITIALIZED = 1,
 MUSOLVER_STATUS_ALLOC_FAILED = 2,
 MUSOLVER_STATUS_INVALID_VALUE = 3,
 MUSOLVER_STATUS_ARCH_MISMATCH = 4,
 MUSOLVER_STATUS_MAPPING_ERROR = 5,
 MUSOLVER_STATUS_EXECUTION_FAILED = 6,
 MUSOLVER_STATUS_INTERNAL_ERROR = 7,
 MUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED = 8,
 MUSOLVER_STATUS_NOT_SUPPORTED = 9,
 MUSOLVER_STATUS_ZERO_PIVOT = 10,
 MUSOLVER_STATUS_INVALID_LICENSE = 11,
 MUSOLVER_STATUS_IRS_PARAMS_NOT_INITIALIZED = 12,
 MUSOLVER_STATUS_IRS_PARAMS_INVALID = 13,
 MUSOLVER_STATUS_IRS_PARAMS_INVALID_PREC = 14,
 MUSOLVER_STATUS_IRS_PARAMS_INVALID_REFINE = 15,
 MUSOLVER_STATUS_IRS_PARAMS_INVALID_MAXITER = 16,
 MUSOLVER_STATUS_IRS_INTERNAL_ERROR = 20,
 MUSOLVER_STATUS_IRS_NOT_SUPPORTED = 21,
 MUSOLVER_STATUS_IRS_OUT_OF_RANGE = 22,
 MUSOLVER_STATUS_IRS_NRHS_NOT_SUPPORTED_FOR_REFINE_GMRES = 23,
 MUSOLVER_STATUS_IRS_INFOS_NOT_INITIALIZED = 25,
 MUSOLVER_STATUS_IRS_INFOS_NOT_DESTROYED = 26,
 MUSOLVER_STATUS_IRS_MATRIX_SINGULAR = 30,
 MUSOLVER_STATUS_INVALID_WORKSPACE = 31
}

Enumerator MUSOLVER_STATUS_SUCCESS

Enumerator MUSOLVER_STATUS_NOT_INITIALIZED

Enumerator MUSOLVER_STATUS_ALLOC_FAILED

Enumerator MUSOLVER_STATUS_INVALID_VALUE

Enumerator MUSOLVER_STATUS_ARCH_MISMATCH

Enumerator MUSOLVER_STATUS_MAPPING_ERROR

Enumerator MUSOLVER_STATUS_EXECUTION_FAILED

Enumerator MUSOLVER_STATUS_INTERNAL_ERROR

Enumerator MUSOLVER_STATUS_MATRIX_TYPE_NOT_SUPPORTED

Enumerator MUSOLVER_STATUS_NOT_SUPPORTED

Enumerator MUSOLVER_STATUS_ZERO_PIVOT

Enumerator MUSOLVER_STATUS_INVALID_LICENSE

Enumerator MUSOLVER_STATUS_IRS_PARAMS_NOT_INITIALIZED

Enumerator MUSOLVER_STATUS_IRS_PARAMS_INVALID

Enumerator MUSOLVER_STATUS_IRS_PARAMS_INVALID_PREC

Enumerator MUSOLVER_STATUS_IRS_PARAMS_INVALID_REFINE

Enumerator MUSOLVER_STATUS_IRS_PARAMS_INVALID_MAXITER

Enumerator MUSOLVER_STATUS_IRS_INTERNAL_ERROR

Enumerator MUSOLVER_STATUS_IRS_NOT_SUPPORTED

Enumerator MUSOLVER_STATUS_IRS_OUT_OF_RANGE

Enumerator MUSOLVER_STATUS_IRS_NRHS_NOT_SUPPORTED_FOR_REFINE_GMRES

Enumerator MUSOLVER_STATUS_IRS_INFOS_NOT_INITIALIZED

Enumerator MUSOLVER_STATUS_IRS_INFOS_NOT_DESTROYED

Enumerator MUSOLVER_STATUS_IRS_MATRIX_SINGULAR

Enumerator MUSOLVER_STATUS_INVALID_WORKSPACE

Enumeration type mublasLayerModeEx_t

Definition: musolver\_common.h (line 72)

enum mublasLayerModeEx_t {
 MUBLAS_LAYER_MODE_EX_LOG_KERNEL = 0x10
}

Used to expand the logging layer modes offered for muSOLVER logging.

Enumerator MUBLAS_LAYER_MODE_EX_LOG_KERNEL

Enable logging for kernel calls.

Enumeration type mublasDirect_t

Definition: musolver\_common.h (line 80)

enum mublasDirect_t {
 MUBLAS_FORWARD_DIRECTION = 171,
 MUBLAS_BACKWARD_DIRECTION = 172
}

Used to specify the order in which multiple Householder matrices are applied together.

Enumerator MUBLAS_FORWARD_DIRECTION

Householder matrices applied from the right.

Enumerator MUBLAS_BACKWARD_DIRECTION

Householder matrices applied from the left.

Enumeration type mublasStorev_t

Definition: musolver\_common.h (line 89)

enum mublasStorev_t {
 MUBLAS_COLUMN_WISE = 181,
 MUBLAS_ROW_WISE = 182
}

Used to specify how householder vectors are stored in a matrix of vectors.

Enumerator MUBLAS_COLUMN_WISE

Householder vectors are stored in the columns of a matrix.

Enumerator MUBLAS_ROW_WISE

Householder vectors are stored in the rows of a matrix.

Enumeration type mublasSvect_t

Definition: musolver\_common.h (line 98)

enum mublasSvect_t {
 MUBLAS_SVECT_ALL = 191,
 MUBLAS_SVECT_SINGULAR = 192,
 MUBLAS_SVECT_OVERWRITE = 193,
 MUBLAS_SVECT_NONE = 194
}

Used to specify how the singular vectors are to be computed and stored.

Enumerator MUBLAS_SVECT_ALL

The entire associated orthogonal/unitary matrix is computed.

Enumerator MUBLAS_SVECT_SINGULAR

Only the singular vectors are computed and stored in output array.

Enumerator MUBLAS_SVECT_OVERWRITE

Only the singular vectors are computed and overwrite the input matrix.

Enumerator MUBLAS_SVECT_NONE

No singular vectors are computed.

Enumeration type mublasWorkmode_t

Definition: musolver\_common.h (line 111)

enum mublasWorkmode_t {
 MUBLAS_OUTOFPLACE = 201,
 MUBLAS_INPLACE = 202
}

Used to enable the use of fast algorithms (with out-of-place computations) in some of the routines.

Enumerator MUBLAS_OUTOFPLACE

Out-of-place computations are allowed; this requires extra device memory for workspace.

Enumerator MUBLAS_INPLACE

If not enough memory is available, this forces in-place computations.

Enumeration type mublasEvect_t

Definition: musolver\_common.h (line 121)

enum mublasEvect_t {
 MUBLAS_EVECT_ORIGINAL = 211,
 MUBLAS_EVECT_TRIDIAGONAL = 212,
 MUBLAS_EVECT_NONE = 213
}

Used to specify how the eigenvectors are to be computed.

Enumerator MUBLAS_EVECT_ORIGINAL

Compute eigenvectors for the original symmetric/Hermitian matrix.

Enumerator MUBLAS_EVECT_TRIDIAGONAL

Compute eigenvectors for the symmetric tridiagonal matrix.

Enumerator MUBLAS_EVECT_NONE

No eigenvectors are computed.

Enumeration type mublasEform_t

Definition: musolver\_common.h (line 132)

enum mublasEform_t {
 MUBLAS_EFORM_AX = 221,
 MUBLAS_EFORM_ABX = 222,
 MUBLAS_EFORM_BAX = 223
}

Used to specify the form of the generalized eigenproblem.

Enumerator MUBLAS_EFORM_AX

The problem is formula {"type":"element","name":"formula","attributes":{"id":"0"},"children":[{"type":"text","text":"$Ax = \\lambda Bx$"}]}.

Enumerator MUBLAS_EFORM_ABX

The problem is formula {"type":"element","name":"formula","attributes":{"id":"1"},"children":[{"type":"text","text":"$ABx = \\lambda x$"}]}.

Enumerator MUBLAS_EFORM_BAX

The problem is formula {"type":"element","name":"formula","attributes":{"id":"2"},"children":[{"type":"text","text":"$BAx = \\lambda x$"}]}.

Enumeration type mublasErange_t

Definition: musolver\_common.h (line 142)

enum mublasErange_t {
 MUBLAS_ERANGE_ALL = 231,
 MUBLAS_ERANGE_VALUE = 232,
 MUBLAS_ERANGE_INDEX = 233
}

Used to specify the type of range in which eigenvalues will be found in partial eigenvalue decompositions.

Enumerator MUBLAS_ERANGE_ALL

All eigenvalues will be found.

Enumerator MUBLAS_ERANGE_VALUE

All eigenvalues in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]} will be found.

Enumerator MUBLAS_ERANGE_INDEX

The formula {"type":"element","name":"formula","attributes":{"id":"4"},"children":[{"type":"text","text":"$il$"}]}-th through formula {"type":"element","name":"formula","attributes":{"id":"5"},"children":[{"type":"text","text":"$iu$"}]}-th eigenvalues will be found.

Enumeration type mublasEorder_t

Definition: musolver\_common.h (line 153)

enum mublasEorder_t {
 MUBLAS_EORDER_BLOCKS = 241,
 MUBLAS_EORDER_ENTIRE = 242
}

Used to specify whether the eigenvalues are grouped and ordered by blocks.

Enumerator MUBLAS_EORDER_BLOCKS

The computed eigenvalues will be grouped by split-off blocks and arranged in increasing order within each block.

Enumerator MUBLAS_EORDER_ENTIRE

All computed eigenvalues of the entire matrix will be ordered from smallest to largest.

Enumeration type mublasEsort_t

Definition: musolver\_common.h (line 164)

enum mublasEsort_t {
 MUBLAS_ESORT_NONE = 251,
 MUBLAS_ESORT_ASCENDING = 252
}

Used in the Jacobi methods to specify whether the eigenvalues are sorted in increasing order.

Enumerator MUBLAS_ESORT_NONE

The computed eigenvalues will not be sorted.

Enumerator MUBLAS_ESORT_ASCENDING

The computed eigenvalues will be sorted in ascending order.

Enumeration type mublasSrange_t

Definition: musolver\_common.h (line 174)

enum mublasSrange_t {
 MUBLAS_SRANGE_ALL = 261,
 MUBLAS_SRANGE_VALUE = 262,
 MUBLAS_SRANGE_INDEX = 263
}

Used to specify the type of range in which singular values will be found in partial singular value decompositions.

Enumerator MUBLAS_SRANGE_ALL

All singular values will be found.

Enumerator MUBLAS_SRANGE_VALUE

All singular values in the half-open interval formula {"type":"element","name":"formula","attributes":{"id":"3"},"children":[{"type":"text","text":"$(vl, vu]$"}]} will be found.

Enumerator MUBLAS_SRANGE_INDEX

The formula {"type":"element","name":"formula","attributes":{"id":"4"},"children":[{"type":"text","text":"$il$"}]}-th through formula {"type":"element","name":"formula","attributes":{"id":"5"},"children":[{"type":"text","text":"$iu$"}]}-th singular values will be found.

Enumeration type musolverEigMode_t

Definition: musolver\_common.h (line 183)

enum musolverEigMode_t {
 MUSOLVER_EIG_MODE_NOVECTOR = 301,
 MUSOLVER_EIG_MODE_VECTOR = 302
}

Enumerator MUSOLVER_EIG_MODE_NOVECTOR

Enumerator MUSOLVER_EIG_MODE_VECTOR

Typedefs

Typedef musolverDnHandle_t

Definition: musolver\_common.h (line 66)

typedef mublasHandle_t musolverDnHandle_t

Return type: mublasHandle_t

Typedef mublasLayerModeFlags

Definition: musolver\_common.h (line 68)

typedef uint32_t mublasLayerModeFlags

Return type: uint32_t

Typedef mublasLayerModeEx

Definition: musolver\_common.h (line 75)

typedef enum mublasLayerModeEx_t mublasLayerModeEx

Used to expand the logging layer modes offered for muSOLVER logging.

Return type: enum mublasLayerModeEx_t

Typedef mublasDirect

Definition: musolver\_common.h (line 84)

typedef enum mublasDirect_t mublasDirect

Used to specify the order in which multiple Householder matrices are applied together.

Return type: enum mublasDirect_t

Typedef mublasStorev

Definition: musolver\_common.h (line 93)

typedef enum mublasStorev_t mublasStorev

Used to specify how householder vectors are stored in a matrix of vectors.

Return type: enum mublasStorev_t

Typedef mublasSvect

Definition: musolver\_common.h (line 106)

typedef enum mublasSvect_t mublasSvect

Used to specify how the singular vectors are to be computed and stored.

Return type: enum mublasSvect_t

Typedef mublasWorkmode

Definition: musolver\_common.h (line 117)

typedef enum mublasWorkmode_t mublasWorkmode

Used to enable the use of fast algorithms (with out-of-place computations) in some of the routines.

Return type: enum mublasWorkmode_t

Typedef mublasEvect

Definition: musolver\_common.h (line 128)

typedef enum mublasEvect_t mublasEvect

Used to specify how the eigenvectors are to be computed.

Return type: enum mublasEvect_t

Typedef mublasEform

Definition: musolver\_common.h (line 137)

typedef enum mublasEform_t mublasEform

Used to specify the form of the generalized eigenproblem.

Return type: enum mublasEform_t

Typedef mublasErange

Definition: musolver\_common.h (line 148)

typedef enum mublasErange_t mublasErange

Used to specify the type of range in which eigenvalues will be found in partial eigenvalue decompositions.

Return type: enum mublasErange_t

Typedef mublasEorder

Definition: musolver\_common.h (line 159)

typedef enum mublasEorder_t mublasEorder

Used to specify whether the eigenvalues are grouped and ordered by blocks.

Return type: enum mublasEorder_t

Typedef mublasEsort

Definition: musolver\_common.h (line 169)

typedef enum mublasEsort_t mublasEsort

Used in the Jacobi methods to specify whether the eigenvalues are sorted in increasing order.

Return type: enum mublasEsort_t

Typedef mublasSrange

Definition: musolver\_common.h (line 181)

typedef enum mublasSrange_t mublasSrange

Used to specify the type of range in which singular values will be found in partial singular value decompositions.

Return type: enum mublasSrange_t

Typedef musolverRfinfo

Definition: musolver\_common.h (line 199)

typedef struct musolverRfinfo_t* musolverRfinfo

A handle to a structure containing matrix descriptors and metadata required to interact with muSPARSE when using the muSOLVER re-factorization functionality. It needs to be initialized with musolverDnCreateRfinfo and destroyed with musolverDnDestroyRfinfo.

Return type: struct musolverRfinfo_t *

---