hipfort_hipsolver Module Reference

Data Types | Functions/Subroutines

hipfort_hipsolver Module Reference

Data Types
interface	hipsolvercreate
interface	hipsolverdestroy
interface	hipsolversetstream
interface	hipsolvergetstream
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

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
	)