hipfort_hipsolver Module Reference

hipfort_hipsolver Module Reference#

HIPFORT API Reference: hipfort_hipsolver Module Reference
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()