hipfort_hipsolver Module Reference

hipfort_hipsolver Module Reference#

HIPFORT API Reference: hipfort_hipsolver Module Reference

Data Types
interface	hipsolvercreate

interface	hipsolverdncreate

interface	hipsolverdestroy

interface	hipsolverdndestroy

interface	hipsolversetstream

interface	hipsolverdnsetstream

interface	hipsolvergetstream

interface	hipsolverdngetstream

interface	hipsolversetdeterministicmode

interface	hipsolvergetdeterministicmode

interface	hipsolversorgbr_buffersize

interface	hipsolverdorgbr_buffersize

interface	hipsolvercungbr_buffersize

interface	hipsolverzungbr_buffersize

interface	hipsolversorgbr

interface	hipsolverdorgbr

interface	hipsolvercungbr

interface	hipsolverzungbr

interface	hipsolversorgqr_buffersize

interface	hipsolverdorgqr_buffersize

interface	hipsolvercungqr_buffersize

interface	hipsolverzungqr_buffersize

interface	hipsolversorgqr

interface	hipsolverdorgqr

interface	hipsolvercungqr

interface	hipsolverzungqr

interface	hipsolversorgtr_buffersize

interface	hipsolverdorgtr_buffersize

interface	hipsolvercungtr_buffersize

interface	hipsolverzungtr_buffersize

interface	hipsolversorgtr

interface	hipsolverdorgtr

interface	hipsolvercungtr

interface	hipsolverzungtr

interface	hipsolversormqr_buffersize

interface	hipsolverdormqr_buffersize

interface	hipsolvercunmqr_buffersize

interface	hipsolverzunmqr_buffersize

interface	hipsolversormqr

interface	hipsolverdormqr

interface	hipsolvercunmqr

interface	hipsolverzunmqr

interface	hipsolversormtr_buffersize

interface	hipsolverdormtr_buffersize

interface	hipsolvercunmtr_buffersize

interface	hipsolverzunmtr_buffersize

interface	hipsolversormtr

interface	hipsolverdormtr

interface	hipsolvercunmtr

interface	hipsolverzunmtr

interface	hipsolversgebrd_buffersize

interface	hipsolverdgebrd_buffersize

interface	hipsolvercgebrd_buffersize

interface	hipsolverzgebrd_buffersize

interface	hipsolversgebrd

interface	hipsolverdgebrd

interface	hipsolvercgebrd

interface	hipsolverzgebrd

interface	hipsolversgeqrf_buffersize

interface	hipsolverdgeqrf_buffersize

interface	hipsolvercgeqrf_buffersize

interface	hipsolverzgeqrf_buffersize

interface	hipsolversgeqrf

interface	hipsolverdgeqrf

interface	hipsolvercgeqrf

interface	hipsolverzgeqrf

interface	hipsolverssgesv_buffersize

interface	hipsolverddgesv_buffersize

interface	hipsolverccgesv_buffersize

interface	hipsolverzzgesv_buffersize

interface	hipsolverssgesv

interface	hipsolverddgesv

interface	hipsolverccgesv

interface	hipsolverzzgesv

interface	hipsolversgetrf_buffersize

interface	hipsolverdgetrf_buffersize

interface	hipsolvercgetrf_buffersize

interface	hipsolverzgetrf_buffersize

interface	hipsolversgetrf

interface	hipsolverdgetrf

interface	hipsolvercgetrf

interface	hipsolverzgetrf

interface	hipsolversgetrs_buffersize

interface	hipsolverdgetrs_buffersize

interface	hipsolvercgetrs_buffersize

interface	hipsolverzgetrs_buffersize

interface	hipsolversgetrs

interface	hipsolverdgetrs

interface	hipsolvercgetrs

interface	hipsolverzgetrs

interface	hipsolverspotrf_buffersize

interface	hipsolverdpotrf_buffersize

interface	hipsolvercpotrf_buffersize

interface	hipsolverzpotrf_buffersize

interface	hipsolverspotrf

interface	hipsolverdpotrf

interface	hipsolvercpotrf

interface	hipsolverzpotrf

interface	hipsolverspotrfbatched_buffersize

interface	hipsolverdpotrfbatched_buffersize

interface	hipsolvercpotrfbatched_buffersize

interface	hipsolverzpotrfbatched_buffersize

interface	hipsolverspotrfbatched

interface	hipsolverdpotrfbatched

interface	hipsolvercpotrfbatched

interface	hipsolverzpotrfbatched

interface	hipsolverspotri_buffersize

interface	hipsolverdpotri_buffersize

interface	hipsolvercpotri_buffersize

interface	hipsolverzpotri_buffersize

interface	hipsolverspotri

interface	hipsolverdpotri

interface	hipsolvercpotri

interface	hipsolverzpotri

interface	hipsolverspotrs_buffersize

interface	hipsolverdpotrs_buffersize

interface	hipsolvercpotrs_buffersize

interface	hipsolverzpotrs_buffersize

interface	hipsolverspotrs

interface	hipsolverdpotrs

interface	hipsolvercpotrs

interface	hipsolverzpotrs

interface	hipsolverspotrsbatched_buffersize

interface	hipsolverdpotrsbatched_buffersize

interface	hipsolvercpotrsbatched_buffersize

interface	hipsolverzpotrsbatched_buffersize

interface	hipsolverspotrsbatched

interface	hipsolverdpotrsbatched

interface	hipsolvercpotrsbatched

interface	hipsolverzpotrsbatched

interface	hipsolverssyevd_buffersize

interface	hipsolverdsyevd_buffersize

interface	hipsolvercheevd_buffersize

interface	hipsolverzheevd_buffersize

interface	hipsolverssyevd

interface	hipsolverdsyevd

interface	hipsolvercheevd

interface	hipsolverzheevd

interface	hipsolverssygvd_buffersize

interface	hipsolverdsygvd_buffersize

interface	hipsolverchegvd_buffersize

interface	hipsolverzhegvd_buffersize

interface	hipsolverssygvd

interface	hipsolverdsygvd

interface	hipsolverchegvd

interface	hipsolverzhegvd

interface	hipsolverssytrd_buffersize

interface	hipsolverdsytrd_buffersize

interface	hipsolverchetrd_buffersize

interface	hipsolverzhetrd_buffersize

interface	hipsolverssytrd

interface	hipsolverdsytrd

interface	hipsolverchetrd

interface	hipsolverzhetrd

interface	hipsolverssytrf_buffersize

interface	hipsolverdsytrf_buffersize

interface	hipsolvercsytrf_buffersize

interface	hipsolverzsytrf_buffersize

interface	hipsolverssytrf

interface	hipsolverdsytrf

interface	hipsolvercsytrf

interface	hipsolverzsytrf

interface	hipsolverssyevdx_buffersize

interface	hipsolverddyevdx_buffersize

interface	hipsolvercheevdx_buffersize

interface	hipsolverzheevdx_buffersize

interface	hipsolverssyevdx_

interface	hipsolverddyevdx

interface	hipsolvercheevdx

interface	hipsolverzheevdx

interface	hipsolverssygvdx_buffersize

interface	hipsolverdsygvdx_buffersize

interface	hipsolverchegvdx_buffersize

interface	hipsolverzhegvdx_buffersize

interface	hipsolverssygvdx

interface	hipsolverdsygvdx

interface	hipsolverchegvdx

interface	hipsolverzhegvdx

interface	hipsolversgesvdj_buffersize

interface	hipsolverdgesvdj_buffersize

interface	hipsolvercgesvdj_buffersize

interface	hipsolverzgesvdj_buffersize

interface	hipsolversgesvdj

interface	hipsolverdgesvdj

interface	hipsolvercgesvdj

interface	hipsolverzgesvdj

interface	hipsolversgesvdjbatched_buffersize

interface	hipsolverdgesvdjbatched_buffersize

interface	hipsolvercgesvdjbatched_buffersize

interface	hipsolverzgesvdjbatched_buffersize

interface	hipsolversgesvdjbatched

interface	hipsolverdgesvdjbatched

interface	hipsolvercgesvdjbatched

interface	hipsolverzgesvdjbatched

interface	hipsolverssyevj_buffersize

interface	hipsolverdsyevj_buffersize

interface	hipsolvercheevj_buffersize

interface	hipsolverzheevj_buffersize

interface	hipsolverssyevj

interface	hipsolverdsyevj

interface	hipsolvercheevj

interface	hipsolverzheevj

interface	hipsolverssyevjbatched_buffersize

interface	hipsolverdsyevjbatched_buffersize

interface	hipsolvercheevjbatched_buffersize

interface	hipsolverzheevjbatched_buffersize

interface	hipsolverssyevjbatched

interface	hipsolverdsyevjjbatched

interface	hipsolvercheevjbatched

interface	hipsolverzheevjbatched

interface	hipsolverssygvj_buffersize

interface	hipsolverdsygvj_buffersize

interface	hipsolverchegvj_buffersize

interface	hipsolverzhegvj_buffersize

interface	hipsolverssygvj

interface	hipsolverdsygvj

interface	hipsolverchegvj

interface	hipsolverzhegvj

interface	hipsolverdncreateparams

interface	hipsolverdndestroyparams

interface	hipsolverdnsetadvoptions

interface	hipsolverdnxgetrf_buffersize

interface	hipsolverdnxgetrf

interface	hipsolverdnxgetrs

interface	hipsolverspcreate

interface	hipsolverspdestroy

interface	hipsolverspsetstream

interface	hipsolverspscsrlsvchol

interface	hipsolverspdcsrlsvchol

interface	hipsolverspscsrlsvcholhost

interface	hipsolverspdscrlsvcholhost

interface	hipsolverrfcreate

interface	hipsolverrfdestroy

interface	hipsolverrfsetupdevice

interface	hipsolverrfsetuphost

interface	hipsolverrfaccessbundledfactorsdevice

interface	hipsolverrfanalyze

interface	hipsolverrfextractbundledfactorshost

interface	hipsolverrfextractsplitfactorshost

interface	hipsolverrfget_algs

interface	hipsolverrfgetmatrixformat

interface	hipsolverrfgetnumericboostreport

interface	hipsolverrfgetnumericproperties

interface	hipsolverrfgetresetvaluesfastmode

interface	hipsolverrfrefactor

interface	hipsolverrfresetvalues

interface	hipsolverrfsetalgs

interface	hipsolverrfsetmatrixformat

interface	hipsolverrfsetnumericproperties

interface	hipsolverrfsetresetvaluesfastmode

interface	hipsolverrfsolve

interface	hipsolverrfbatchsetuphost

interface	hipsolverrfbatchanalyze

interface	hipsolverrfbatchrefactor

interface	hipsolverrfbatchresetvalues

interface	hipsolverrfbatchsolve

interface	hipsolverrfbatchzeropivot

Functions/Subroutines
integer(kind(hipsolver_status_success)) function	hipsolversorgbr_buffersize_full_rank (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgbr_buffersize_rank_0 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgbr_buffersize_rank_1 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgbr_buffersize_full_rank (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgbr_buffersize_rank_0 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgbr_buffersize_rank_1 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungbr_buffersize_full_rank (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungbr_buffersize_rank_0 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungbr_buffersize_rank_1 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungbr_buffersize_full_rank (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungbr_buffersize_rank_0 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungbr_buffersize_rank_1 (handle, side, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgbr_full_rank (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgbr_rank_0 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgbr_rank_1 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgbr_full_rank (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgbr_rank_0 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgbr_rank_1 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungbr_full_rank (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungbr_rank_0 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungbr_rank_1 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungbr_full_rank (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungbr_rank_0 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungbr_rank_1 (handle, side, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgqr_buffersize_full_rank (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgqr_buffersize_rank_0 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgqr_buffersize_rank_1 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgqr_buffersize_full_rank (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgqr_buffersize_rank_0 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgqr_buffersize_rank_1 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungqr_buffersize_full_rank (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungqr_buffersize_rank_0 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungqr_buffersize_rank_1 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungqr_buffersize_full_rank (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungqr_buffersize_rank_0 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungqr_buffersize_rank_1 (handle, m, n, k, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgqr_full_rank (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgqr_rank_0 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgqr_rank_1 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgqr_full_rank (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgqr_rank_0 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgqr_rank_1 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungqr_full_rank (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungqr_rank_0 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungqr_rank_1 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungqr_full_rank (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungqr_rank_0 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungqr_rank_1 (handle, m, n, k, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgtr_buffersize_full_rank (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgtr_buffersize_rank_0 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgtr_buffersize_rank_1 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgtr_buffersize_full_rank (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgtr_buffersize_rank_0 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdorgtr_buffersize_rank_1 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungtr_buffersize_full_rank (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungtr_buffersize_rank_0 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercungtr_buffersize_rank_1 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungtr_buffersize_full_rank (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungtr_buffersize_rank_0 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzungtr_buffersize_rank_1 (handle, uplo, n, A, lda, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversorgtr_full_rank (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgtr_rank_0 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversorgtr_rank_1 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgtr_full_rank (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgtr_rank_0 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdorgtr_rank_1 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungtr_full_rank (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungtr_rank_0 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercungtr_rank_1 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungtr_full_rank (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungtr_rank_0 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzungtr_rank_1 (handle, uplo, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversormqr_buffersize_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversormqr_buffersize_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversormqr_buffersize_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdormqr_buffersize_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdormqr_buffersize_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdormqr_buffersize_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercunmqr_buffersize_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercunmqr_buffersize_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercunmqr_buffersize_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzunmqr_buffersize_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzunmqr_buffersize_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzunmqr_buffersize_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversormqr_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversormqr_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversormqr_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdormqr_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdormqr_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdormqr_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercunmqr_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercunmqr_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercunmqr_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzunmqr_full_rank (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzunmqr_rank_0 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzunmqr_rank_1 (handle, side, trans, m, n, k, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversormtr_buffersize_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversormtr_buffersize_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversormtr_buffersize_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdormtr_buffersize_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdormtr_buffersize_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdormtr_buffersize_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercunmtr_buffersize_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercunmtr_buffersize_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercunmtr_buffersize_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzunmtr_buffersize_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzunmtr_buffersize_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzunmtr_buffersize_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversormtr_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversormtr_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversormtr_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdormtr_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdormtr_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdormtr_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercunmtr_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercunmtr_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercunmtr_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzunmtr_full_rank (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzunmtr_rank_0 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzunmtr_rank_1 (handle, side, uplo, trans, m, n, A, lda, tau, C, ldc, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgebrd_full_rank (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgebrd_rank_0 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgebrd_rank_1 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgebrd_full_rank (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgebrd_rank_0 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgebrd_rank_1 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgebrd_full_rank (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgebrd_rank_0 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgebrd_rank_1 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgebrd_full_rank (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgebrd_rank_0 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgebrd_rank_1 (handle, m, n, A, lda, D, E, tauq, taup, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgeqrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgeqrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgeqrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgeqrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgeqrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgeqrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgeqrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgeqrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgeqrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgeqrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgeqrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgeqrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgeqrf_full_rank (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgeqrf_rank_0 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgeqrf_rank_1 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgeqrf_full_rank (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgeqrf_rank_0 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgeqrf_rank_1 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgeqrf_full_rank (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgeqrf_rank_0 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgeqrf_rank_1 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgeqrf_full_rank (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgeqrf_rank_0 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgeqrf_rank_1 (handle, m, n, A, lda, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssgesv_buffersize_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssgesv_buffersize_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssgesv_buffersize_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverddgesv_buffersize_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverddgesv_buffersize_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverddgesv_buffersize_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverccgesv_buffersize_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverccgesv_buffersize_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverccgesv_buffersize_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzzgesv_buffersize_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzzgesv_buffersize_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzzgesv_buffersize_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssgesv_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssgesv_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssgesv_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverddgesv_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverddgesv_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverddgesv_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverccgesv_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverccgesv_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverccgesv_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzzgesv_full_rank (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzzgesv_rank_0 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzzgesv_rank_1 (handle, n, nrhs, A, lda, devIpiv, B, ldb, X, ldx, work, lwork, niters, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgetrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgetrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgetrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrf_buffersize_full_rank (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrf_buffersize_rank_0 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrf_buffersize_rank_1 (handle, m, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgetrf_full_rank (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgetrf_rank_0 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgetrf_rank_1 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrf_full_rank (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrf_rank_0 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrf_rank_1 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrf_full_rank (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrf_rank_0 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrf_rank_1 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrf_full_rank (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrf_rank_0 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrf_rank_1 (handle, m, n, A, lda, work, lwork, devIpiv, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgetrs_buffersize_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgetrs_buffersize_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgetrs_buffersize_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrs_buffersize_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrs_buffersize_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrs_buffersize_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrs_buffersize_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrs_buffersize_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrs_buffersize_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrs_buffersize_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrs_buffersize_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrs_buffersize_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolversgetrs_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgetrs_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolversgetrs_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrs_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrs_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdgetrs_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrs_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrs_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercgetrs_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrs_full_rank (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrs_rank_0 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzgetrs_rank_1 (handle, trans, n, nrhs, A, lda, devIpiv, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrf_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotrf_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotrf_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrf_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrf_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrf_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrf_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrf_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrf_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrf_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrf_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrf_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotrf_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrf_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrf_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrf_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrf_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrf_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrf_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrf_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrf_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrf_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrf_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrf_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrfbatched_buffersize_full_rank (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrfbatched_buffersize_rank_0 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrfbatched_buffersize_rank_1 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrfbatched_buffersize_full_rank (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrfbatched_buffersize_rank_0 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrfbatched_buffersize_rank_1 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrfbatched_buffersize_full_rank (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrfbatched_buffersize_rank_0 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrfbatched_buffersize_rank_1 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrfbatched_buffersize_full_rank (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrfbatched_buffersize_rank_0 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrfbatched_buffersize_rank_1 (handle, uplo, n, A, lda, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrfbatched_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrfbatched_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrfbatched_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrfbatched_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrfbatched_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrfbatched_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrfbatched_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrfbatched_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrfbatched_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrfbatched_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrfbatched_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrfbatched_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotri_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotri_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotri_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotri_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotri_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotri_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotri_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotri_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotri_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotri_buffersize_full_rank (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotri_buffersize_rank_0 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotri_buffersize_rank_1 (handle, uplo, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotri_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotri_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotri_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotri_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotri_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotri_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotri_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotri_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotri_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotri_full_rank (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotri_rank_0 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotri_rank_1 (handle, uplo, n, A, lda, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrs_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotrs_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotrs_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrs_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrs_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrs_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrs_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrs_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrs_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrs_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrs_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrs_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverspotrs_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrs_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrs_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrs_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrs_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrs_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrs_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrs_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrs_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrs_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrs_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrs_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverspotrsbatched_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrsbatched_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrsbatched_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrsbatched_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrsbatched_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrsbatched_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrsbatched_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrsbatched_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrsbatched_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrsbatched_buffersize_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrsbatched_buffersize_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrsbatched_buffersize_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, lwork, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrsbatched_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrsbatched_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverspotrsbatched_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrsbatched_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrsbatched_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverdpotrsbatched_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrsbatched_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrsbatched_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolvercpotrsbatched_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrsbatched_full_rank (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrsbatched_rank_0 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverzpotrsbatched_rank_1 (handle, uplo, n, nrhs, A, lda, B, ldb, work, lwork, devInfo, batch_count)

integer(kind(hipsolver_status_success)) function	hipsolverssyevd_buffersize_full_rank (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssyevd_buffersize_rank_0 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssyevd_buffersize_rank_1 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsyevd_buffersize_full_rank (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsyevd_buffersize_rank_0 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsyevd_buffersize_rank_1 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercheevd_buffersize_full_rank (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercheevd_buffersize_rank_0 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercheevd_buffersize_rank_1 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzheevd_buffersize_full_rank (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzheevd_buffersize_rank_0 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzheevd_buffersize_rank_1 (handle, jobz, uplo, n, A, lda, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssyevd_full_rank (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssyevd_rank_0 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssyevd_rank_1 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsyevd_full_rank (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsyevd_rank_0 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsyevd_rank_1 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercheevd_full_rank (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercheevd_rank_0 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercheevd_rank_1 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzheevd_full_rank (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzheevd_rank_0 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzheevd_rank_1 (handle, jobz, uplo, n, A, lda, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssygvd_buffersize_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssygvd_buffersize_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssygvd_buffersize_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsygvd_buffersize_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsygvd_buffersize_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsygvd_buffersize_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverchegvd_buffersize_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverchegvd_buffersize_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverchegvd_buffersize_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzhegvd_buffersize_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzhegvd_buffersize_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzhegvd_buffersize_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssygvd_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssygvd_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssygvd_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsygvd_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsygvd_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsygvd_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverchegvd_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverchegvd_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverchegvd_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzhegvd_full_rank (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzhegvd_rank_0 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzhegvd_rank_1 (handle, itype, jobz, uplo, n, A, lda, B, ldb, D, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssytrd_buffersize_full_rank (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssytrd_buffersize_rank_0 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssytrd_buffersize_rank_1 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrd_buffersize_full_rank (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrd_buffersize_rank_0 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrd_buffersize_rank_1 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverchetrd_buffersize_full_rank (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverchetrd_buffersize_rank_0 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverchetrd_buffersize_rank_1 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzhetrd_buffersize_full_rank (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzhetrd_buffersize_rank_0 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzhetrd_buffersize_rank_1 (handle, uplo, n, A, lda, D, E, tau, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssytrd_full_rank (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssytrd_rank_0 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssytrd_rank_1 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrd_full_rank (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrd_rank_0 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrd_rank_1 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverchetrd_full_rank (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverchetrd_rank_0 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverchetrd_rank_1 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzhetrd_full_rank (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzhetrd_rank_0 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzhetrd_rank_1 (handle, uplo, n, A, lda, D, E, tau, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssytrf_buffersize_full_rank (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssytrf_buffersize_rank_0 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssytrf_buffersize_rank_1 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrf_buffersize_full_rank (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrf_buffersize_rank_0 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrf_buffersize_rank_1 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercsytrf_buffersize_full_rank (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercsytrf_buffersize_rank_0 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolvercsytrf_buffersize_rank_1 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzsytrf_buffersize_full_rank (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzsytrf_buffersize_rank_0 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverzsytrf_buffersize_rank_1 (handle, n, A, lda, lwork)

integer(kind(hipsolver_status_success)) function	hipsolverssytrf_full_rank (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssytrf_rank_0 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverssytrf_rank_1 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrf_full_rank (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrf_rank_0 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverdsytrf_rank_1 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercsytrf_full_rank (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercsytrf_rank_0 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolvercsytrf_rank_1 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzsytrf_full_rank (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzsytrf_rank_0 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

integer(kind(hipsolver_status_success)) function	hipsolverzsytrf_rank_1 (handle, uplo, n, A, lda, ipiv, work, lwork, devInfo)

Function/Subroutine Documentation

◆ hipsolverccgesv_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverccgesv_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		complex(c_float_complex), dimension(:,:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverccgesv_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverccgesv_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		complex(c_float_complex), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverccgesv_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverccgesv_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		complex(c_float_complex), dimension(:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverccgesv_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverccgesv_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		complex(c_float_complex), dimension(:,:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverccgesv_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverccgesv_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		complex(c_float_complex), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverccgesv_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverccgesv_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		complex(c_float_complex), dimension(:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolvercgebrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgebrd_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		complex(c_float_complex), dimension(:), target	tauq,
		complex(c_float_complex), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgebrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgebrd_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		real(c_float), target	E,
		complex(c_float_complex), target	tauq,
		complex(c_float_complex), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgebrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgebrd_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		complex(c_float_complex), dimension(:), target	tauq,
		complex(c_float_complex), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgeqrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgeqrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercgeqrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgeqrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercgeqrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgeqrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercgeqrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgeqrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgeqrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgeqrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgeqrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgeqrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgetrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercgetrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercgetrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercgetrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolvercgetrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolvercgetrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolvercgetrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolvercgetrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolvercgetrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolvercgetrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgetrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercgetrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercgetrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercheevd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercheevd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolvercheevd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercheevd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		integer(c_int)	lwork
	)

◆ hipsolvercheevd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercheevd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolvercheevd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercheevd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercheevd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercheevd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercheevd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercheevd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverchegvd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchegvd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverchegvd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchegvd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		real(c_float), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverchegvd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchegvd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverchegvd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchegvd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverchegvd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchegvd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		real(c_float), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverchegvd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchegvd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverchetrd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchetrd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverchetrd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchetrd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		real(c_float), target	E,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverchetrd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchetrd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverchetrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchetrd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverchetrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchetrd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		real(c_float), target	E,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverchetrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverchetrd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercpotrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercpotrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercpotrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrfbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrfbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrfbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrfbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrfbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrfbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrfbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrfbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrfbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrfbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrfbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrfbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotri_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotri_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercpotri_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotri_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercpotri_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotri_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercpotri_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotri_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotri_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotri_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotri_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotri_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolvercpotrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolvercpotrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolvercpotrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercpotrsbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrsbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrsbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrsbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrsbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrsbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrsbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrsbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrsbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrsbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolvercpotrsbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercpotrsbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolvercsytrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercsytrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercsytrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercsytrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercsytrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercsytrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolvercsytrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercsytrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercsytrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercsytrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercsytrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercsytrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungbr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungbr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungbr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungbr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungbr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungbr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungbr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungbr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungbr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungbr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungbr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungbr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungqr_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungqr_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungqr_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolvercungtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercungtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercungtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercunmqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolvercunmqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolvercunmqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolvercunmqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmqr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercunmqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmqr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercunmqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmqr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercunmtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolvercunmtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolvercunmtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolvercunmtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercunmtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolvercunmtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolvercunmtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_float_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_float_complex)	tau,
		complex(c_float_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverddgesv_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverddgesv_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:,:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverddgesv_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverddgesv_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_double), target	B,
		integer(c_int)	ldb,
		real(c_double), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverddgesv_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverddgesv_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverddgesv_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverddgesv_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:,:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverddgesv_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverddgesv_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_double), target	B,
		integer(c_int)	ldb,
		real(c_double), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverddgesv_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverddgesv_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverdgebrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgebrd_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		real(c_double), dimension(:), target	tauq,
		real(c_double), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgebrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgebrd_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		real(c_double), target	E,
		real(c_double), target	tauq,
		real(c_double), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgebrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgebrd_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		real(c_double), dimension(:), target	tauq,
		real(c_double), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgeqrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgeqrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdgeqrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgeqrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdgeqrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgeqrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdgeqrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgeqrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgeqrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgeqrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgeqrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgeqrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgetrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdgetrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdgetrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdgetrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolverdgetrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolverdgetrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolverdgetrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverdgetrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_double), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverdgetrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverdgetrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgetrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_double), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdgetrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdgetrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgbr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgbr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgbr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgbr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgbr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgbr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgbr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgbr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgbr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgbr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgbr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgbr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgqr_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgqr_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgqr_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdorgtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdorgtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdorgtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdormqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverdormqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverdormqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverdormqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormqr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdormqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormqr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdormqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormqr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdormtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverdormtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverdormtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverdormtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdormtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdormtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdormtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double)	tau,
		real(c_double), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdpotrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdpotrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdpotrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrfbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrfbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrfbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrfbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrfbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrfbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrfbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrfbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrfbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrfbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrfbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrfbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotri_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotri_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdpotri_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotri_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdpotri_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotri_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdpotri_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotri_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotri_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotri_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotri_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotri_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverdpotrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverdpotrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverdpotrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdpotrsbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrsbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrsbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrsbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrsbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrsbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrsbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrsbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrsbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrsbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverdpotrsbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdpotrsbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverdsyevd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsyevd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverdsyevd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsyevd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverdsyevd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsyevd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverdsyevd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsyevd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsyevd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsyevd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsyevd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsyevd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsygvd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsygvd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverdsygvd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsygvd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	B,
		integer(c_int)	ldb,
		real(c_double), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverdsygvd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsygvd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverdsygvd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsygvd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsygvd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsygvd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	B,
		integer(c_int)	ldb,
		real(c_double), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsygvd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsygvd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsytrd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdsytrd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		real(c_double), target	E,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdsytrd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		real(c_double)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverdsytrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsytrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		real(c_double), target	E,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsytrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		real(c_double)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsytrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdsytrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdsytrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverdsytrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsytrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverdsytrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverdsytrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_double), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgebrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgebrd_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		real(c_float), dimension(:), target	tauq,
		real(c_float), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgebrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgebrd_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		real(c_float), target	E,
		real(c_float), target	tauq,
		real(c_float), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgebrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgebrd_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		real(c_float), dimension(:), target	tauq,
		real(c_float), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgeqrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgeqrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolversgeqrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgeqrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolversgeqrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgeqrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolversgeqrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgeqrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgeqrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgeqrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgeqrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgeqrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgetrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolversgetrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolversgetrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolversgetrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolversgetrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolversgetrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolversgetrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolversgetrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_float), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolversgetrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolversgetrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgetrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_float), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversgetrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversgetrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgbr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgbr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgbr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgbr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgbr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgbr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgbr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgbr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgbr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgbr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgbr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgbr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgqr_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgqr_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgqr_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolversorgtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversorgtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversorgtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversormqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolversormqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolversormqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolversormqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormqr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversormqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormqr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversormqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormqr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversormtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolversormtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolversormtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolversormtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversormtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolversormtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolversormtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float)	tau,
		real(c_float), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverspotrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverspotrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverspotrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrfbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrfbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrfbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrfbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrfbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrfbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrfbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrfbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrfbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrfbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrfbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrfbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverspotri_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotri_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverspotri_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotri_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverspotri_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotri_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverspotri_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotri_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotri_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotri_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotri_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotri_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverspotrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverspotrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverspotrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverspotrsbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrsbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrsbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrsbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrsbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrsbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrsbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrsbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrsbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrsbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverspotrsbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverspotrsbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverssgesv_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssgesv_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:,:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverssgesv_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssgesv_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_float), target	B,
		integer(c_int)	ldb,
		real(c_float), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverssgesv_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssgesv_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverssgesv_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssgesv_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:,:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverssgesv_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssgesv_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		real(c_float), target	B,
		integer(c_int)	ldb,
		real(c_float), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverssgesv_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssgesv_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverssyevd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssyevd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverssyevd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssyevd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverssyevd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssyevd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverssyevd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssyevd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssyevd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssyevd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssyevd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssyevd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssygvd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssygvd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverssygvd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssygvd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	B,
		integer(c_int)	ldb,
		real(c_float), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverssygvd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssygvd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverssygvd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssygvd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssygvd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssygvd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	B,
		integer(c_int)	ldb,
		real(c_float), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssygvd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssygvd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_float), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssytrd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverssytrd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		real(c_float), target	E,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverssytrd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		real(c_float)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverssytrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssytrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		real(c_float), target	D,
		real(c_float), target	E,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssytrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_float), dimension(:), target	D,
		real(c_float), dimension(:), target	E,
		real(c_float)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssytrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverssytrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverssytrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverssytrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssytrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverssytrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverssytrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		real(c_float), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgebrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgebrd_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		complex(c_double_complex), dimension(:), target	tauq,
		complex(c_double_complex), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgebrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgebrd_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		real(c_double), target	E,
		complex(c_double_complex), target	tauq,
		complex(c_double_complex), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgebrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgebrd_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		complex(c_double_complex), dimension(:), target	tauq,
		complex(c_double_complex), dimension(:), target	taup,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgeqrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgeqrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzgeqrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgeqrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzgeqrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgeqrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzgeqrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgeqrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgeqrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgeqrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgeqrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgeqrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgetrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzgetrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzgetrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzgetrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrf_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolverzgetrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrf_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolverzgetrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrf_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int), dimension(:), target	devIpiv,
		integer(c_int)	devInfo
	)

◆ hipsolverzgetrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverzgetrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverzgetrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverzgetrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgetrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzgetrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzgetrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzheevd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzheevd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverzheevd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzheevd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverzheevd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzheevd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverzheevd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzheevd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzheevd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzheevd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzheevd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzheevd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzhegvd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhegvd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverzhegvd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhegvd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		real(c_double), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverzhegvd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhegvd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		integer(c_int)	lwork
	)

◆ hipsolverzhegvd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhegvd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzhegvd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhegvd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		real(c_double), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzhegvd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhegvd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_eig_type_1))	itype,
		integer(kind(hipsolver_eig_mode_novector))	jobz,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		real(c_double), dimension(:), target	D,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzhetrd_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhetrd_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzhetrd_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhetrd_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		real(c_double), target	E,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzhetrd_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhetrd_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzhetrd_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhetrd_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzhetrd_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhetrd_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		real(c_double), target	D,
		real(c_double), target	E,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzhetrd_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzhetrd_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		real(c_double), dimension(:), target	D,
		real(c_double), dimension(:), target	E,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzpotrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzpotrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzpotrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrfbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrfbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrfbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrfbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrfbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrfbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrfbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrfbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrfbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrfbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrfbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrfbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotri_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotri_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzpotri_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotri_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzpotri_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotri_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzpotri_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotri_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotri_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotri_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotri_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotri_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrs_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrs_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverzpotrs_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrs_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverzpotrs_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrs_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork
	)

◆ hipsolverzpotrs_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrs_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrs_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrs_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrs_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrs_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzpotrsbatched_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrsbatched_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrsbatched_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrsbatched_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrsbatched_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrsbatched_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		integer(c_int)	lwork,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrsbatched_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrsbatched_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:,:,:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrsbatched_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrsbatched_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverzpotrsbatched_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzpotrsbatched_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo,
		integer(c_int)	batch_count
	)

◆ hipsolverzsytrf_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzsytrf_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzsytrf_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzsytrf_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzsytrf_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzsytrf_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int)	lwork
	)

◆ hipsolverzsytrf_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzsytrf_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzsytrf_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzsytrf_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzsytrf_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzsytrf_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		type(c_ptr)	ipiv,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungbr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungbr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungbr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungbr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungbr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungbr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungbr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungbr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungbr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungbr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungbr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungbr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungqr_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungqr_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungqr_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		integer(c_int)	lwork
	)

◆ hipsolverzungtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzungtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzungtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzunmqr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmqr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverzunmqr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmqr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverzunmqr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmqr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverzunmqr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmqr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzunmqr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmqr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzunmqr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmqr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		integer(c_int)	k,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzunmtr_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmtr_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverzunmtr_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmtr_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverzunmtr_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmtr_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		integer(c_int)	lwork
	)

◆ hipsolverzunmtr_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmtr_full_rank	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:,:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzunmtr_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmtr_rank_0	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzunmtr_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzunmtr_rank_1	(	type(c_ptr)	handle,
		integer(kind(hipsolver_side_left))	side,
		integer(kind(hipsolver_fill_mode_upper))	uplo,
		integer(kind(hipsolver_op_n))	trans,
		integer(c_int)	m,
		integer(c_int)	n,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		complex(c_double_complex)	tau,
		complex(c_double_complex), dimension(:), target	C,
		integer(c_int)	ldc,
		type(c_ptr)	work,
		integer(c_int)	lwork,
		integer(c_int)	devInfo
	)

◆ hipsolverzzgesv_buffersize_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzzgesv_buffersize_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		complex(c_double_complex), dimension(:,:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverzzgesv_buffersize_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzzgesv_buffersize_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		complex(c_double_complex), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverzzgesv_buffersize_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzzgesv_buffersize_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		complex(c_double_complex), dimension(:), target	X,
		integer(c_int)	ldx,
		integer(c_size_t)	lwork
	)

◆ hipsolverzzgesv_full_rank()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzzgesv_full_rank	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:,:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:,:), target	B,
		integer(c_int)	ldb,
		complex(c_double_complex), dimension(:,:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverzzgesv_rank_0()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzzgesv_rank_0	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), target	A,
		integer(c_int)	lda,
		integer(c_int), target	devIpiv,
		complex(c_double_complex), target	B,
		integer(c_int)	ldb,
		complex(c_double_complex), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

◆ hipsolverzzgesv_rank_1()

integer(kind(hipsolver_status_success)) function hipfort_hipsolver::hipsolverzzgesv_rank_1	(	type(c_ptr)	handle,
		integer(c_int)	n,
		integer(c_int)	nrhs,
		complex(c_double_complex), dimension(:), target	A,
		integer(c_int)	lda,
		integer(c_int), dimension(:), target	devIpiv,
		complex(c_double_complex), dimension(:), target	B,
		integer(c_int)	ldb,
		complex(c_double_complex), dimension(:), target	X,
		integer(c_int)	ldx,
		type(c_ptr)	work,
		integer(c_size_t)	lwork,
		type(c_ptr)	niters,
		integer(c_int)	devInfo
	)

hipfort_hipsolver Module Reference

hipfort_hipsolver Module Reference#

Data Types

Functions/Subroutines

Function/Subroutine Documentation

◆ hipsolverccgesv_buffersize_full_rank()

◆ hipsolverccgesv_buffersize_rank_0()

◆ hipsolverccgesv_buffersize_rank_1()

◆ hipsolverccgesv_full_rank()

◆ hipsolverccgesv_rank_0()

◆ hipsolverccgesv_rank_1()

◆ hipsolvercgebrd_full_rank()

◆ hipsolvercgebrd_rank_0()

◆ hipsolvercgebrd_rank_1()

◆ hipsolvercgeqrf_buffersize_full_rank()

◆ hipsolvercgeqrf_buffersize_rank_0()

◆ hipsolvercgeqrf_buffersize_rank_1()

◆ hipsolvercgeqrf_full_rank()

◆ hipsolvercgeqrf_rank_0()

◆ hipsolvercgeqrf_rank_1()

◆ hipsolvercgetrf_buffersize_full_rank()

◆ hipsolvercgetrf_buffersize_rank_0()

◆ hipsolvercgetrf_buffersize_rank_1()

◆ hipsolvercgetrf_full_rank()

◆ hipsolvercgetrf_rank_0()

◆ hipsolvercgetrf_rank_1()

◆ hipsolvercgetrs_buffersize_full_rank()

◆ hipsolvercgetrs_buffersize_rank_0()

◆ hipsolvercgetrs_buffersize_rank_1()

◆ hipsolvercgetrs_full_rank()

◆ hipsolvercgetrs_rank_0()

◆ hipsolvercgetrs_rank_1()

◆ hipsolvercheevd_buffersize_full_rank()

◆ hipsolvercheevd_buffersize_rank_0()

◆ hipsolvercheevd_buffersize_rank_1()

◆ hipsolvercheevd_full_rank()

◆ hipsolvercheevd_rank_0()

◆ hipsolvercheevd_rank_1()

◆ hipsolverchegvd_buffersize_full_rank()

◆ hipsolverchegvd_buffersize_rank_0()

◆ hipsolverchegvd_buffersize_rank_1()

◆ hipsolverchegvd_full_rank()

◆ hipsolverchegvd_rank_0()

◆ hipsolverchegvd_rank_1()

◆ hipsolverchetrd_buffersize_full_rank()

◆ hipsolverchetrd_buffersize_rank_0()

◆ hipsolverchetrd_buffersize_rank_1()

◆ hipsolverchetrd_full_rank()

◆ hipsolverchetrd_rank_0()

◆ hipsolverchetrd_rank_1()

◆ hipsolvercpotrf_buffersize_full_rank()

◆ hipsolvercpotrf_buffersize_rank_0()

◆ hipsolvercpotrf_buffersize_rank_1()

◆ hipsolvercpotrf_full_rank()

◆ hipsolvercpotrf_rank_0()

◆ hipsolvercpotrf_rank_1()

◆ hipsolvercpotrfbatched_buffersize_full_rank()

◆ hipsolvercpotrfbatched_buffersize_rank_0()

◆ hipsolvercpotrfbatched_buffersize_rank_1()

◆ hipsolvercpotrfbatched_full_rank()

◆ hipsolvercpotrfbatched_rank_0()

◆ hipsolvercpotrfbatched_rank_1()

◆ hipsolvercpotri_buffersize_full_rank()

◆ hipsolvercpotri_buffersize_rank_0()

◆ hipsolvercpotri_buffersize_rank_1()

◆ hipsolvercpotri_full_rank()

◆ hipsolvercpotri_rank_0()

◆ hipsolvercpotri_rank_1()

◆ hipsolvercpotrs_buffersize_full_rank()

◆ hipsolvercpotrs_buffersize_rank_0()

◆ hipsolvercpotrs_buffersize_rank_1()

◆ hipsolvercpotrs_full_rank()

◆ hipsolvercpotrs_rank_0()

◆ hipsolvercpotrs_rank_1()

◆ hipsolvercpotrsbatched_buffersize_full_rank()

◆ hipsolvercpotrsbatched_buffersize_rank_0()

◆ hipsolvercpotrsbatched_buffersize_rank_1()

◆ hipsolvercpotrsbatched_full_rank()

◆ hipsolvercpotrsbatched_rank_0()

◆ hipsolvercpotrsbatched_rank_1()