Skip to main content
`Ctrl`+`K`

# Dense matrix LAPACK functions

LAPACK routines solve complex numerical linear algebra problems. These functions are organized into the following categories:

- Triangular factorizations: Based on Gaussian elimination.

- Orthogonal factorizations: Based on Householder reflections.

- Problem and matrix reductions: Transformation of matrices and problems into equivalent forms.

- Linear-systems solvers: Based on triangular factorizations.

- Least-squares solvers: Based on orthogonal factorizations.

- Symmetric eigensolvers: Eigenproblems for symmetric matrices.

- Singular value decomposition: Singular values and related problems for general matrices.

## Triangular factorizations

### hipsolverDn<type>potrf_bufferSize()

hipsolverStatus_t hipsolverDnXpotrf_bufferSize(hipsolverDnHandle_t handle, hipsolverDnParams_t params, hipsolverFillMode_t uplo, int64_t n, hipDataType dataTypeA, const void *A, int64_t lda, hipDataType computeType, size_t *lworkOnDevice, size_t *lworkOnHost)

hipsolverStatus_t hipsolverDnZpotrf_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnCpotrf_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnDpotrf_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, double *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnSpotrf_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, float *A, int lda, int *lwork)

### hipsolverDn<type>potrf()

hipsolverStatus_t hipsolverDnXpotrf(hipsolverDnHandle_t handle, hipsolverDnParams_t params, hipsolverFillMode_t uplo, int64_t n, hipDataType dataTypeA, void *A, int64_t lda, hipDataType computeType, void *workOnDevice, size_t lworkOnDevice, void *workOnHost, size_t lworkOnHost, int *info)

hipsolverStatus_t hipsolverDnZpotrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnCpotrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, hipFloatComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnDpotrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, double *A, int lda, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSpotrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, float *A, int lda, float *work, int lwork, int *devInfo)

### hipsolverDn<type>potrfBatched()

hipsolverStatus_t hipsolverDnZpotrfBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipDoubleComplex *A[], int lda, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDnCpotrfBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipFloatComplex *A[], int lda, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDnDpotrfBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, double *A[], int lda, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDnSpotrfBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, float *A[], int lda, int *devInfo, int batch_count)

### hipsolverDn<type>getrf_bufferSize()

hipsolverStatus_t hipsolverDnXgetrf_bufferSize(hipsolverDnHandle_t handle, hipsolverDnParams_t params, int64_t m, int64_t n, hipDataType dataTypeA, const void *A, int64_t lda, hipDataType computeType, size_t *lworkOnDevice, size_t *lworkOnHost)

hipsolverStatus_t hipsolverDnZgetrf_bufferSize(hipsolverHandle_t handle, int m, int n, hipDoubleComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnCgetrf_bufferSize(hipsolverHandle_t handle, int m, int n, hipFloatComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnDgetrf_bufferSize(hipsolverHandle_t handle, int m, int n, double *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnSgetrf_bufferSize(hipsolverHandle_t handle, int m, int n, float *A, int lda, int *lwork)

### hipsolverDn<type>getrf()

hipsolverStatus_t hipsolverDnXgetrf(hipsolverDnHandle_t handle, hipsolverDnParams_t params, int64_t m, int64_t n, hipDataType dataTypeA, void *A, int64_t lda, int64_t *devIpiv, hipDataType computeType, void *workOnDevice, size_t lworkOnDevice, void *workOnHost, size_t lworkOnHost, int *devInfo)

hipsolverStatus_t hipsolverDnZgetrf(hipsolverHandle_t handle, int m, int n, hipDoubleComplex *A, int lda, hipDoubleComplex *work, int *devIpiv, int *devInfo)

hipsolverStatus_t hipsolverDnCgetrf(hipsolverHandle_t handle, int m, int n, hipFloatComplex *A, int lda, hipFloatComplex *work, int *devIpiv, int *devInfo)

hipsolverStatus_t hipsolverDnDgetrf(hipsolverHandle_t handle, int m, int n, double *A, int lda, double *work, int *devIpiv, int *devInfo)

hipsolverStatus_t hipsolverDnSgetrf(hipsolverHandle_t handle, int m, int n, float *A, int lda, float *work, int *devIpiv, int *devInfo)

### hipsolverDn<type>sytrf_bufferSize()

hipsolverStatus_t hipsolverDnZsytrf_bufferSize(hipsolverHandle_t handle, int n, hipDoubleComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnCsytrf_bufferSize(hipsolverHandle_t handle, int n, hipFloatComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnDsytrf_bufferSize(hipsolverHandle_t handle, int n, double *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnSsytrf_bufferSize(hipsolverHandle_t handle, int n, float *A, int lda, int *lwork)

### hipsolverDn<type>sytrf()

hipsolverStatus_t hipsolverDnZsytrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, int *ipiv, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnCsytrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, int *ipiv, hipFloatComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnDsytrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, double *A, int lda, int *ipiv, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSsytrf(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, float *A, int lda, int *ipiv, float *work, int lwork, int *devInfo)

## Orthogonal factorizations

### hipsolverDn<type>geqrf_bufferSize()

hipsolverStatus_t hipsolverDnXgeqrf_bufferSize(hipsolverDnHandle_t handle, hipsolverDnParams_t params, int64_t m, int64_t n, hipDataType dataTypeA, const void *A, int64_t lda, hipDataType dataTypeTau, const void *tau, hipDataType computeType, size_t *lworkOnDevice, size_t *lworkOnHost)

hipsolverStatus_t hipsolverDnZgeqrf_bufferSize(hipsolverHandle_t handle, int m, int n, hipDoubleComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnCgeqrf_bufferSize(hipsolverHandle_t handle, int m, int n, hipFloatComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnDgeqrf_bufferSize(hipsolverHandle_t handle, int m, int n, double *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnSgeqrf_bufferSize(hipsolverHandle_t handle, int m, int n, float *A, int lda, int *lwork)

### hipsolverDn<type>geqrf()

hipsolverStatus_t hipsolverDnXgeqrf(hipsolverDnHandle_t handle, hipsolverDnParams_t params, int64_t m, int64_t n, hipDataType dataTypeA, void *A, int64_t lda, hipDataType dataTypeTau, void *tau, hipDataType computeType, void *workOnDevice, size_t lworkOnDevice, void *workOnHost, size_t lworkOnHost, int *devInfo)

hipsolverStatus_t hipsolverDnZgeqrf(hipsolverHandle_t handle, int m, int n, hipDoubleComplex *A, int lda, hipDoubleComplex *tau, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnCgeqrf(hipsolverHandle_t handle, int m, int n, hipFloatComplex *A, int lda, hipFloatComplex *tau, hipFloatComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnDgeqrf(hipsolverHandle_t handle, int m, int n, double *A, int lda, double *tau, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSgeqrf(hipsolverHandle_t handle, int m, int n, float *A, int lda, float *tau, float *work, int lwork, int *devInfo)

## Problem and matrix reductions

### hipsolverDn<type>gebrd_bufferSize()

hipsolverStatus_t hipsolverDnZgebrd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

hipsolverStatus_t hipsolverDnCgebrd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

hipsolverStatus_t hipsolverDnDgebrd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

hipsolverStatus_t hipsolverDnSgebrd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

### hipsolverDn<type>gebrd()

hipsolverStatus_t hipsolverDnZgebrd(hipsolverHandle_t handle, int m, int n, hipDoubleComplex *A, int lda, double *D, double *E, hipDoubleComplex *tauq, hipDoubleComplex *taup, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnCgebrd(hipsolverHandle_t handle, int m, int n, hipFloatComplex *A, int lda, float *D, float *E, hipFloatComplex *tauq, hipFloatComplex *taup, hipFloatComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnDgebrd(hipsolverHandle_t handle, int m, int n, double *A, int lda, double *D, double *E, double *tauq, double *taup, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSgebrd(hipsolverHandle_t handle, int m, int n, float *A, int lda, float *D, float *E, float *tauq, float *taup, float *work, int lwork, int *devInfo)

### hipsolverDn<type>sytrd_bufferSize()

hipsolverStatus_t hipsolverDnDsytrd_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, const double *A, int lda, const double *D, const double *E, const double *tau, int *lwork)

hipsolverStatus_t hipsolverDnSsytrd_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, const float *A, int lda, const float *D, const float *E, const float *tau, int *lwork)

### hipsolverDn<type>hetrd_bufferSize()

hipsolverStatus_t hipsolverDnZhetrd_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, const hipDoubleComplex *A, int lda, const double *D, const double *E, const hipDoubleComplex *tau, int *lwork)

hipsolverStatus_t hipsolverDnChetrd_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, const hipFloatComplex *A, int lda, const float *D, const float *E, const hipFloatComplex *tau, int *lwork)

### hipsolverDn<type>sytrd()

hipsolverStatus_t hipsolverDnDsytrd(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, double *A, int lda, double *D, double *E, double *tau, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSsytrd(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, float *A, int lda, float *D, float *E, float *tau, float *work, int lwork, int *devInfo)

### hipsolverDn<type>hetrd()

hipsolverStatus_t hipsolverDnZhetrd(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, double *D, double *E, hipDoubleComplex *tau, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnChetrd(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, float *D, float *E, hipFloatComplex *tau, hipFloatComplex *work, int lwork, int *devInfo)

## Linear-systems solvers

### hipsolverDn<type>potri_bufferSize()

hipsolverStatus_t hipsolverDnZpotri_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnCpotri_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnDpotri_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, double *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDnSpotri_bufferSize(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, float *A, int lda, int *lwork)

### hipsolverDn<type>potri()

hipsolverStatus_t hipsolverDnZpotri(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnCpotri(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, hipFloatComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnDpotri(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, double *A, int lda, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSpotri(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, float *A, int lda, float *work, int lwork, int *devInfo)

### hipsolverDn<type>potrs()

hipsolverStatus_t hipsolverDnXpotrs(hipsolverDnHandle_t handle, hipsolverDnParams_t params, hipsolverFillMode_t uplo, int64_t n, int64_t nrhs, hipDataType dataTypeA, const void *A, int64_t lda, hipDataType dataTypeB, void *B, int64_t ldb, int *info)

hipsolverStatus_t hipsolverDnZpotrs(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, const hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, int *devInfo)

hipsolverStatus_t hipsolverDnCpotrs(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, const hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, int *devInfo)

hipsolverStatus_t hipsolverDnDpotrs(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, const double *A, int lda, double *B, int ldb, int *devInfo)

hipsolverStatus_t hipsolverDnSpotrs(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, const float *A, int lda, float *B, int ldb, int *devInfo)

### hipsolverDn<type>potrsBatched()

hipsolverStatus_t hipsolverDnZpotrsBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, hipDoubleComplex *A[], int lda, hipDoubleComplex *B[], int ldb, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDnCpotrsBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, hipFloatComplex *A[], int lda, hipFloatComplex *B[], int ldb, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDnDpotrsBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, double *A[], int lda, double *B[], int ldb, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDnSpotrsBatched(hipsolverHandle_t handle, hipblasFillMode_t uplo, int n, int nrhs, float *A[], int lda, float *B[], int ldb, int *devInfo, int batch_count)

### hipsolverDn<type>getrs()

hipsolverStatus_t hipsolverDnXgetrs(hipsolverDnHandle_t handle, hipsolverDnParams_t params, hipsolverOperation_t trans, int64_t n, int64_t nrhs, hipDataType dataTypeA, const void *A, int64_t lda, const int64_t *devIpiv, hipDataType dataTypeB, void *B, int64_t ldb, int *devInfo)

hipsolverStatus_t hipsolverDnZgetrs(hipsolverHandle_t handle, hipblasOperation_t trans, int n, int nrhs, const hipDoubleComplex *A, int lda, const int *devIpiv, hipDoubleComplex *B, int ldb, int *devInfo)

hipsolverStatus_t hipsolverDnCgetrs(hipsolverHandle_t handle, hipblasOperation_t trans, int n, int nrhs, const hipFloatComplex *A, int lda, const int *devIpiv, hipFloatComplex *B, int ldb, int *devInfo)

hipsolverStatus_t hipsolverDnDgetrs(hipsolverHandle_t handle, hipblasOperation_t trans, int n, int nrhs, const double *A, int lda, const int *devIpiv, double *B, int ldb, int *devInfo)

hipsolverStatus_t hipsolverDnSgetrs(hipsolverHandle_t handle, hipblasOperation_t trans, int n, int nrhs, const float *A, int lda, const int *devIpiv, float *B, int ldb, int *devInfo)

### hipsolverDn<type><type>gesv_bufferSize()

hipsolverStatus_t hipsolverDnZZgesv_bufferSize(hipsolverHandle_t handle, int n, int nrhs, hipDoubleComplex *A, int lda, int *devIpiv, hipDoubleComplex *B, int ldb, hipDoubleComplex *X, int ldx, void *work, size_t *lwork)

hipsolverStatus_t hipsolverDnCCgesv_bufferSize(hipsolverHandle_t handle, int n, int nrhs, hipFloatComplex *A, int lda, int *devIpiv, hipFloatComplex *B, int ldb, hipFloatComplex *X, int ldx, void *work, size_t *lwork)

hipsolverStatus_t hipsolverDnDDgesv_bufferSize(hipsolverHandle_t handle, int n, int nrhs, double *A, int lda, int *devIpiv, double *B, int ldb, double *X, int ldx, void *work, size_t *lwork)

hipsolverStatus_t hipsolverDnSSgesv_bufferSize(hipsolverHandle_t handle, int n, int nrhs, float *A, int lda, int *devIpiv, float *B, int ldb, float *X, int ldx, void *work, size_t *lwork)

### hipsolverDn<type><type>gesv()

hipsolverStatus_t hipsolverDnZZgesv(hipsolverHandle_t handle, int n, int nrhs, hipDoubleComplex *A, int lda, int *devIpiv, hipDoubleComplex *B, int ldb, hipDoubleComplex *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

hipsolverStatus_t hipsolverDnCCgesv(hipsolverHandle_t handle, int n, int nrhs, hipFloatComplex *A, int lda, int *devIpiv, hipFloatComplex *B, int ldb, hipFloatComplex *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

hipsolverStatus_t hipsolverDnDDgesv(hipsolverHandle_t handle, int n, int nrhs, double *A, int lda, int *devIpiv, double *B, int ldb, double *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

hipsolverStatus_t hipsolverDnSSgesv(hipsolverHandle_t handle, int n, int nrhs, float *A, int lda, int *devIpiv, float *B, int ldb, float *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

## Least-squares solvers

### hipsolverDn<type><type>gels_bufferSize()

hipsolverStatus_t hipsolverDnZZgels_bufferSize(hipsolverHandle_t handle, int m, int n, int nrhs, hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, hipDoubleComplex *X, int ldx, void *work, size_t *lwork)

hipsolverStatus_t hipsolverDnCCgels_bufferSize(hipsolverHandle_t handle, int m, int n, int nrhs, hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, hipFloatComplex *X, int ldx, void *work, size_t *lwork)

hipsolverStatus_t hipsolverDnDDgels_bufferSize(hipsolverHandle_t handle, int m, int n, int nrhs, double *A, int lda, double *B, int ldb, double *X, int ldx, void *work, size_t *lwork)

hipsolverStatus_t hipsolverDnSSgels_bufferSize(hipsolverHandle_t handle, int m, int n, int nrhs, float *A, int lda, float *B, int ldb, float *X, int ldx, void *work, size_t *lwork)

### hipsolverDn<type><type>gels()

hipsolverStatus_t hipsolverDnZZgels(hipsolverHandle_t handle, int m, int n, int nrhs, hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, hipDoubleComplex *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

hipsolverStatus_t hipsolverDnCCgels(hipsolverHandle_t handle, int m, int n, int nrhs, hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, hipFloatComplex *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

hipsolverStatus_t hipsolverDnDDgels(hipsolverHandle_t handle, int m, int n, int nrhs, double *A, int lda, double *B, int ldb, double *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

hipsolverStatus_t hipsolverDnSSgels(hipsolverHandle_t handle, int m, int n, int nrhs, float *A, int lda, float *B, int ldb, float *X, int ldx, void *work, size_t lwork, int *niters, int *devInfo)

## Symmetric eigensolvers

### hipsolverDn<type>syevd_bufferSize()

hipsolverStatus_t hipsolverDnDsyevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const double *A, int lda, const double *W, int *lwork)

hipsolverStatus_t hipsolverDnSsyevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const float *A, int lda, const float *W, int *lwork)

### hipsolverDn<type>heevd_bufferSize()

hipsolverStatus_t hipsolverDnZheevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const hipDoubleComplex *A, int lda, const double *W, int *lwork)

hipsolverStatus_t hipsolverDnCheevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const hipFloatComplex *A, int lda, const float *W, int *lwork)

### hipsolverDn<type>syevd()

hipsolverStatus_t hipsolverDnDsyevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, double *A, int lda, double *W, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSsyevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, float *A, int lda, float *W, float *work, int lwork, int *devInfo)

### hipsolverDn<type>heevd()

hipsolverStatus_t hipsolverDnZheevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, double *W, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnCheevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, float *W, hipFloatComplex *work, int lwork, int *devInfo)

### hipsolverDn<type>sygvd_bufferSize()

hipsolverStatus_t hipsolverDnDsygvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const double *A, int lda, const double *B, int ldb, const double *W, int *lwork)

hipsolverStatus_t hipsolverDnSsygvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const float *A, int lda, const float *B, int ldb, const float *W, int *lwork)

### hipsolverDn<type>hegvd_bufferSize()

hipsolverStatus_t hipsolverDnZhegvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const hipDoubleComplex *A, int lda, const hipDoubleComplex *B, int ldb, const double *W, int *lwork)

hipsolverStatus_t hipsolverDnChegvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, const hipFloatComplex *A, int lda, const hipFloatComplex *B, int ldb, const float *W, int *lwork)

### hipsolverDn<type>sygvd()

hipsolverStatus_t hipsolverDnDsygvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, double *A, int lda, double *B, int ldb, double *W, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnSsygvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, float *A, int lda, float *B, int ldb, float *W, float *work, int lwork, int *devInfo)

### hipsolverDn<type>hegvd()

hipsolverStatus_t hipsolverDnZhegvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, double *W, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDnChegvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipblasFillMode_t uplo, int n, hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, float *W, hipFloatComplex *work, int lwork, int *devInfo)

## Singular value decomposition

### hipsolverDn<type>gesvd_bufferSize()

hipsolverStatus_t hipsolverDnZgesvd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

hipsolverStatus_t hipsolverDnCgesvd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

hipsolverStatus_t hipsolverDnDgesvd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

hipsolverStatus_t hipsolverDnSgesvd_bufferSize(hipsolverHandle_t handle, int m, int n, int *lwork)

### hipsolverDn<type>gesvd()

hipsolverStatus_t hipsolverDnZgesvd(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, hipDoubleComplex *A, int lda, double *S, hipDoubleComplex *U, int ldu, hipDoubleComplex *V, int ldv, hipDoubleComplex *work, int lwork, double *rwork, int *devInfo)

hipsolverStatus_t hipsolverDnCgesvd(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, hipFloatComplex *A, int lda, float *S, hipFloatComplex *U, int ldu, hipFloatComplex *V, int ldv, hipFloatComplex *work, int lwork, float *rwork, int *devInfo)

hipsolverStatus_t hipsolverDnDgesvd(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, double *A, int lda, double *S, double *U, int ldu, double *V, int ldv, double *work, int lwork, double *rwork, int *devInfo)

hipsolverStatus_t hipsolverDnSgesvd(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, float *A, int lda, float *S, float *U, int ldu, float *V, int ldv, float *work, int lwork, float *rwork, int *devInfo)