2.4. LAPACK Functions

LAPACK routines solve complex Numerical Linear Algebra problems. These functions are organized in 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.

2.4.1. Triangular factorizations

hipsolver<type>potrf_bufferSize()

hipsolverStatus_t hipsolverZpotrf_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverCpotrf_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipFloatComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDpotrf_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, double *A, int lda, int *lwork)

hipsolverStatus_t hipsolverSpotrf_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, float *A, int lda, int *lwork)

hipsolver<type>potrfBatched_bufferSize()

hipsolverStatus_t hipsolverZpotrfBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A[], int lda, int *lwork, int batch_count)

hipsolverStatus_t hipsolverCpotrfBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipFloatComplex *A[], int lda, int *lwork, int batch_count)

hipsolverStatus_t hipsolverDpotrfBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, double *A[], int lda, int *lwork, int batch_count)

hipsolverStatus_t hipsolverSpotrfBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, float *A[], int lda, int *lwork, int batch_count)

hipsolver<type>potrf()

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

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

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

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

hipsolver<type>potrfBatched()

hipsolverStatus_t hipsolverZpotrfBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A[], int lda, hipDoubleComplex *work, int lwork, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverCpotrfBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipFloatComplex *A[], int lda, hipFloatComplex *work, int lwork, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDpotrfBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, double *A[], int lda, double *work, int lwork, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverSpotrfBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, float *A[], int lda, float *work, int lwork, int *devInfo, int batch_count)

hipsolver<type>getrf_bufferSize()

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

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

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

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

hipsolver<type>getrf()

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

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

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

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

hipsolver<type>sytrf_bufferSize()

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

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

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

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

hipsolver<type>sytrf()

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

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

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

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

2.4.2. Orthogonal factorizations

hipsolver<type>geqrf_bufferSize()

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

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

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

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

hipsolver<type>geqrf()

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

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

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

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

2.4.3. Problem and matrix reductions

hipsolver<type>gebrd_bufferSize()

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

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

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

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

hipsolver<type>gebrd()

hipsolverStatus_t hipsolverZgebrd(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 hipsolverCgebrd(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 hipsolverDgebrd(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 hipsolverSgebrd(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)

hipsolver<type>sytrd_bufferSize()

hipsolverStatus_t hipsolverDsytrd_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, double *A, int lda, double *D, double *E, double *tau, int *lwork)

hipsolverStatus_t hipsolverSsytrd_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, float *A, int lda, float *D, float *E, float *tau, int *lwork)

hipsolver<type>hetrd_bufferSize()

hipsolverStatus_t hipsolverZhetrd_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A, int lda, double *D, double *E, hipDoubleComplex *tau, int *lwork)

hipsolverStatus_t hipsolverChetrd_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipFloatComplex *A, int lda, float *D, float *E, hipFloatComplex *tau, int *lwork)

hipsolver<type>sytrd()

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

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

hipsolver<type>hetrd()

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

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

2.4.4. Linear-systems solvers

hipsolver<type>potri_bufferSize()

hipsolverStatus_t hipsolverZpotri_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverCpotri_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, hipFloatComplex *A, int lda, int *lwork)

hipsolverStatus_t hipsolverDpotri_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, double *A, int lda, int *lwork)

hipsolverStatus_t hipsolverSpotri_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, float *A, int lda, int *lwork)

hipsolver<type>potri()

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

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

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

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

hipsolver<type>potrs_bufferSize()

hipsolverStatus_t hipsolverZpotrs_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, int *lwork)

hipsolverStatus_t hipsolverCpotrs_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, int *lwork)

hipsolverStatus_t hipsolverDpotrs_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, double *A, int lda, double *B, int ldb, int *lwork)

hipsolverStatus_t hipsolverSpotrs_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, float *A, int lda, float *B, int ldb, int *lwork)

hipsolver<type>potrsBatched_bufferSize()

hipsolverStatus_t hipsolverZpotrsBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipDoubleComplex *A[], int lda, hipDoubleComplex *B[], int ldb, int *lwork, int batch_count)

hipsolverStatus_t hipsolverCpotrsBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipFloatComplex *A[], int lda, hipFloatComplex *B[], int ldb, int *lwork, int batch_count)

hipsolverStatus_t hipsolverDpotrsBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, double *A[], int lda, double *B[], int ldb, int *lwork, int batch_count)

hipsolverStatus_t hipsolverSpotrsBatched_bufferSize(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, float *A[], int lda, float *B[], int ldb, int *lwork, int batch_count)

hipsolver<type>potrs()

hipsolverStatus_t hipsolverZpotrs(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverCpotrs(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, hipFloatComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDpotrs(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, double *A, int lda, double *B, int ldb, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverSpotrs(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, float *A, int lda, float *B, int ldb, float *work, int lwork, int *devInfo)

hipsolver<type>potrsBatched()

hipsolverStatus_t hipsolverZpotrsBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipDoubleComplex *A[], int lda, hipDoubleComplex *B[], int ldb, hipDoubleComplex *work, int lwork, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverCpotrsBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, hipFloatComplex *A[], int lda, hipFloatComplex *B[], int ldb, hipFloatComplex *work, int lwork, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverDpotrsBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, double *A[], int lda, double *B[], int ldb, double *work, int lwork, int *devInfo, int batch_count)

hipsolverStatus_t hipsolverSpotrsBatched(hipsolverHandle_t handle, hipsolverFillMode_t uplo, int n, int nrhs, float *A[], int lda, float *B[], int ldb, float *work, int lwork, int *devInfo, int batch_count)

hipsolver<type>getrs_bufferSize()

hipsolverStatus_t hipsolverZgetrs_bufferSize(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, hipDoubleComplex *A, int lda, int *devIpiv, hipDoubleComplex *B, int ldb, int *lwork)

hipsolverStatus_t hipsolverCgetrs_bufferSize(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, hipFloatComplex *A, int lda, int *devIpiv, hipFloatComplex *B, int ldb, int *lwork)

hipsolverStatus_t hipsolverDgetrs_bufferSize(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, double *A, int lda, int *devIpiv, double *B, int ldb, int *lwork)

hipsolverStatus_t hipsolverSgetrs_bufferSize(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, float *A, int lda, int *devIpiv, float *B, int ldb, int *lwork)

hipsolver<type>getrs()

hipsolverStatus_t hipsolverZgetrs(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, hipDoubleComplex *A, int lda, int *devIpiv, hipDoubleComplex *B, int ldb, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverCgetrs(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, hipFloatComplex *A, int lda, int *devIpiv, hipFloatComplex *B, int ldb, hipFloatComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverDgetrs(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, double *A, int lda, int *devIpiv, double *B, int ldb, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverSgetrs(hipsolverHandle_t handle, hipsolverOperation_t trans, int n, int nrhs, float *A, int lda, int *devIpiv, float *B, int ldb, float *work, int lwork, int *devInfo)

hipsolver<type><type>gesv_bufferSize()

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

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

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

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

hipsolver<type><type>gesv()

hipsolverStatus_t hipsolverZZgesv(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 hipsolverCCgesv(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 hipsolverDDgesv(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 hipsolverSSgesv(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)

2.4.5. Least-squares solvers

hipsolver<type><type>gels_bufferSize()

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

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

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

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

hipsolver<type><type>gels()

hipsolverStatus_t hipsolverZZgels(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 hipsolverCCgels(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 hipsolverDDgels(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 hipsolverSSgels(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)

2.4.6. Symmetric eigensolvers

hipsolver<type>syevd_bufferSize()

hipsolverStatus_t hipsolverDsyevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, double *A, int lda, double *D, int *lwork)

hipsolverStatus_t hipsolverSsyevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, float *A, int lda, float *D, int *lwork)

hipsolver<type>heevd_bufferSize()

hipsolverStatus_t hipsolverZheevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A, int lda, double *D, int *lwork)

hipsolverStatus_t hipsolverCheevd_bufferSize(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipFloatComplex *A, int lda, float *D, int *lwork)

hipsolver<type>syevd()

hipsolverStatus_t hipsolverDsyevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, double *A, int lda, double *D, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverSsyevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, float *A, int lda, float *D, float *work, int lwork, int *devInfo)

hipsolver<type>heevd()

hipsolverStatus_t hipsolverZheevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A, int lda, double *D, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverCheevd(hipsolverHandle_t handle, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipFloatComplex *A, int lda, float *D, hipFloatComplex *work, int lwork, int *devInfo)

hipsolver<type>sygvd_bufferSize()

hipsolverStatus_t hipsolverDsygvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, double *A, int lda, double *B, int ldb, double *D, int *lwork)

hipsolverStatus_t hipsolverSsygvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, float *A, int lda, float *B, int ldb, float *D, int *lwork)

hipsolver<type>hegvd_bufferSize()

hipsolverStatus_t hipsolverZhegvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, double *D, int *lwork)

hipsolverStatus_t hipsolverChegvd_bufferSize(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, float *D, int *lwork)

hipsolver<type>sygvd()

hipsolverStatus_t hipsolverDsygvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, double *A, int lda, double *B, int ldb, double *D, double *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverSsygvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, float *A, int lda, float *B, int ldb, float *D, float *work, int lwork, int *devInfo)

hipsolver<type>hegvd()

hipsolverStatus_t hipsolverZhegvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipDoubleComplex *A, int lda, hipDoubleComplex *B, int ldb, double *D, hipDoubleComplex *work, int lwork, int *devInfo)

hipsolverStatus_t hipsolverChegvd(hipsolverHandle_t handle, hipsolverEigType_t itype, hipsolverEigMode_t jobz, hipsolverFillMode_t uplo, int n, hipFloatComplex *A, int lda, hipFloatComplex *B, int ldb, float *D, hipFloatComplex *work, int lwork, int *devInfo)

2.4.7. Singular value decomposition

hipsolver<type>gesvd_bufferSize()

hipsolverStatus_t hipsolverZgesvd_bufferSize(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, int *lwork)

hipsolverStatus_t hipsolverCgesvd_bufferSize(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, int *lwork)

hipsolverStatus_t hipsolverDgesvd_bufferSize(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, int *lwork)

hipsolverStatus_t hipsolverSgesvd_bufferSize(hipsolverHandle_t handle, signed char jobu, signed char jobv, int m, int n, int *lwork)

hipsolver<type>gesvd()

hipsolverStatus_t hipsolverZgesvd(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 hipsolverCgesvd(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 hipsolverDgesvd(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 hipsolverSgesvd(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)