MODULE F77_LAPACK ! ! -- LAPACK95 interface driver routine (version 3.0) -- ! UNI-C, Denmark; Univ. of Tennessee, USA; NAG Ltd., UK ! September, 2000 ! INTERFACE LA_LANGB FUNCTION DLANGB( NORM, N, KL, KU, AB, LDAB, WORK ) USE LA_PRECISION, ONLY: WP => DP REAL(WP) :: DLANGB CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: LDAB, N, KL, KU REAL(WP), INTENT(IN) :: AB( LDAB, * ) REAL(WP), INTENT(OUT) :: WORK( * ) END FUNCTION DLANGB END INTERFACE INTERFACE LA_TGSEN SUBROUTINE DTGSEN( IJOB, WANTQ, WANTZ, SELECT, N, A, LDA, B, LDB, & & ALPHAR, ALPHAI, BETA, Q, LDQ, Z, LDZ, M, PL, & & PR, DIF, WORK, LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP LOGICAL, INTENT(IN) :: WANTQ, WANTZ INTEGER, INTENT(IN) :: IJOB, LDA, LDB, LDQ, LDZ, LIWORK, LWORK, N INTEGER, INTENT(OUT) :: INFO, M, IWORK(LIWORK) REAL(WP), INTENT(OUT) :: PL, PR LOGICAL, INTENT(IN) :: SELECT(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*), Q(LDQ,*), Z(LDZ,*) REAL(WP), INTENT(OUT) :: ALPHAI(*), ALPHAR(*), BETA(*), DIF(2), & & WORK(LWORK) END SUBROUTINE DTGSEN END INTERFACE INTERFACE LA_TGSNA SUBROUTINE DTGSNA( JOB, HOWMNY, SELECT, N, A, LDA, B, LDB, VL, & & LDVL, VR, LDVR, S, DIF, MM, M, WORK, LWORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: HOWMNY, JOB INTEGER, INTENT(IN) :: LDA, LDB, LDVL, LDVR, LWORK, MM, N INTEGER, INTENT(OUT) :: INFO, M, IWORK(*) LOGICAL, INTENT(IN) :: SELECT(*) REAL(WP), INTENT(OUT) :: DIF(*), S(*) REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*), VL(LDVL,*), & & VR(LDVR,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DTGSNA END INTERFACE INTERFACE LA_TGSYL SUBROUTINE DTGSYL( TRANS, IJOB, M, N, A, LDA, B, LDB, C, LDC, D, & & LDD, E, LDE, F, LDF, SCALE, DIF, WORK, LWORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: IJOB, LDA, LDB, LDC, LDD, LDE, LDF, LWORK, & & M, N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: DIF, SCALE REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*), D(LDD,*), E(LDF,*) REAL(WP), INTENT(INOUT) :: C(LDC,*), F(LDF,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DTGSYL END INTERFACE INTERFACE LA_TGEXC SUBROUTINE DTGEXC( WANTQ, WANTZ, N, A, LDA, B, LDB, Q, LDQ, Z, & & LDZ, IFST, ILST, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP LOGICAL, INTENT(IN) :: WANTQ, WANTZ INTEGER, INTENT(IN) :: LDA, LDB, LDQ, LDZ, LWORK, N INTEGER, INTENT(INOUT) :: IFST, ILST INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*), Q(LDQ,*), Z(LDZ,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DTGEXC END INTERFACE INTERFACE LA_BDSDC SUBROUTINE DBDSDC( UPLO, COMPQ, N, D, E, U, LDU, VT, LDVT, Q, & & IQ, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPQ, UPLO INTEGER, INTENT(IN) :: LDU, LDVT, N INTEGER, INTENT(OUT) :: INFO, IQ( * ), IWORK( * ) REAL(WP), INTENT(INOUT) :: D( * ), E( * ) REAL(WP), INTENT(OUT) :: Q(*), U(LDU,*), VT(LDVT,*), WORK(*) END SUBROUTINE DBDSDC END INTERFACE INTERFACE LA_STEGR SUBROUTINE DSTEGR( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, & & ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, & & IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE INTEGER, INTENT(IN) :: IL, IU, LDZ, LIWORK, LWORK, N INTEGER, INTENT(OUT) :: INFO, M INTEGER, INTENT(OUT) :: ISUPPZ( * ), IWORK(LIWORK) REAL(WP), INTENT(IN) :: ABSTOL, VL, VU REAL(WP), INTENT(INOUT) :: D( * ), E( * ) REAL(WP), INTENT(IN) :: W( * ) REAL(WP), INTENT(OUT) :: WORK(LWORK) REAL(WP), INTENT(OUT) :: Z( LDZ, * ) END SUBROUTINE DSTEGR END INTERFACE INTERFACE LA_ORMRZ SUBROUTINE DORMRZ( SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, & & LDC, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS INTEGER, INTENT(IN) :: K, L, LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A( LDA, * ), TAU( * ) REAL(WP), INTENT(INOUT) :: C( LDC, * ) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORMRZ END INTERFACE INTERFACE LA_TZRZF SUBROUTINE DTZRZF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: TAU( * ), WORK(LWORK) END SUBROUTINE DTZRZF END INTERFACE INTERFACE LA_GEQP3 SUBROUTINE DGEQP3( M, N, A, LDA, JPVT, TAU, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(INOUT) :: JPVT( * ) REAL(WP), INTENT(INOUT) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: TAU( * ), WORK(LWORK) END SUBROUTINE DGEQP3 END INTERFACE INTERFACE LA_GESDD SUBROUTINE DGESDD( JOBZ, M, N, A, LDA, S, U, LDU, VT, LDVT, & & WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ INTEGER, INTENT(IN) :: M, N, LDA, LDU, LDVT, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: U(LDU,*), VT(LDVT,*), WORK(*) INTEGER :: IWORK(*) END SUBROUTINE DGESDD END INTERFACE INTERFACE LA_GGRQF SUBROUTINE DGGRQF( M, P, N, A, LDA, TAUA, B, LDB, TAUB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LDB, LWORK, M, N, P INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: TAUA(*), TAUB(*), WORK(*) END SUBROUTINE DGGRQF END INTERFACE INTERFACE LA_GGQRF SUBROUTINE DGGQRF( N, M, P, A, LDA, TAUA, B, LDB, TAUB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LDB, LWORK, M, N, P INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: TAUA(*), TAUB(*), WORK(*) END SUBROUTINE DGGQRF END INTERFACE INTERFACE LA_DISNA SUBROUTINE DDISNA( JOB, M, N, D, SEP, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOB INTEGER, INTENT(IN) :: M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(OUT) :: SEP(*) END SUBROUTINE DDISNA END INTERFACE INTERFACE LA_TGSJA SUBROUTINE DTGSJA( JOBU, JOBV, JOBQ, M, P, N, K, L, A, LDA, B, & & LDB, TOLA, TOLB, ALPHA, BETA, U, LDU, V, LDV, & & Q, LDQ, WORK, NCYCLE, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBQ, JOBU, JOBV INTEGER, INTENT(IN) :: K, L, LDA, LDB, LDQ, LDU, LDV, M, N, & & NCYCLE, P INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: TOLA, TOLB REAL(WP), INTENT(OUT) :: ALPHA(*), BETA(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*), Q(LDQ,*), & & U(LDU,*), V(LDV,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTGSJA END INTERFACE INTERFACE LA_GGSVP SUBROUTINE DGGSVP( JOBU, JOBV, JOBQ, M, P, N, A, LDA, B, LDB, & & TOLA, TOLB, K, L, U, LDU, V, LDV, Q, LDQ, & & IWORK, TAU, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBQ, JOBU, JOBV INTEGER, INTENT(IN) :: LDA, LDB, LDQ, LDU, LDV, M, N, P INTEGER, INTENT(OUT) :: INFO, K, L, IWORK(*) REAL(WP), INTENT(IN) :: TOLA, TOLB REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: Q(LDQ,*), TAU(*), U(LDU,*), V(LDV,*), & & WORK(*) END SUBROUTINE DGGSVP END INTERFACE INTERFACE LA_TGEVC SUBROUTINE DTGEVC( SIDE, HOWMNY, SELECT, N, A, LDA, B, LDB, VL, & & LDVL, VR, LDVR, MM, M, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: HOWMNY, SIDE INTEGER, INTENT(IN) :: LDA, LDB, LDVL, LDVR, MM, N INTEGER, INTENT(OUT) :: INFO, M LOGICAL, INTENT(IN) :: SELECT(*) REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(INOUT) :: VL(LDVL,*), VR(LDVR,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTGEVC END INTERFACE INTERFACE LA_HGEQZ SUBROUTINE DHGEQZ( JOB, COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB,& & ALPHAR, ALPHAI, BETA, Q, LDQ, Z, LDZ, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPQ, COMPZ, JOB INTEGER, INTENT(IN) :: IHI, ILO, LDA, LDB, LDQ, LDZ, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*), Q(LDQ,*), & & Z(LDZ,*) REAL(WP), INTENT(OUT) :: ALPHAR(*), ALPHAI(*), BETA(*), WORK(LWORK) END SUBROUTINE DHGEQZ END INTERFACE INTERFACE LA_GGBAK SUBROUTINE DGGBAK( JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V, & & LDV, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOB, SIDE INTEGER, INTENT(IN) :: IHI, ILO, LDV, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: LSCALE(*), RSCALE(*) REAL(WP), INTENT(INOUT) :: V(LDV,*) END SUBROUTINE DGGBAK END INTERFACE INTERFACE LA_GGBAL SUBROUTINE DGGBAL( JOB, N, A, LDA, B, LDB, ILO, IHI, LSCALE, & & RSCALE, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOB INTEGER, INTENT(IN) :: LDA, LDB, N INTEGER, INTENT(OUT) :: IHI, ILO, INFO REAL(WP), INTENT(OUT) :: LSCALE(*), RSCALE(*), WORK(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) END SUBROUTINE DGGBAL END INTERFACE INTERFACE LA_GGHRD SUBROUTINE DGGHRD( COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB, Q, & & LDQ, Z, LDZ, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPQ, COMPZ INTEGER, INTENT(IN) :: IHI, ILO, LDA, LDB, LDQ, LDZ, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*), Q(LDQ,*), & & Z(LDZ,*) END SUBROUTINE DGGHRD END INTERFACE INTERFACE LA_PBSTF SUBROUTINE DPBSTF( UPLO, N, KD, AB, LDAB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) ::UPLO INTEGER, INTENT(IN) :: KD, LDAB, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB( LDAB, * ) END SUBROUTINE DPBSTF END INTERFACE INTERFACE LA_SBGST SUBROUTINE DSBGST( VECT, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, X, & & LDX, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, VECT INTEGER, INTENT(IN) :: KA, KB, LDAB, LDBB, LDX, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: BB(LDBB,*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*) REAL(WP), INTENT(OUT) :: WORK(*), X(LDX,*) END SUBROUTINE DSBGST END INTERFACE INTERFACE LA_SPGST SUBROUTINE DSPGST( ITYPE, UPLO, N, AP, BP, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: ITYPE, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: BP(*) REAL(WP), INTENT(INOUT) :: AP(*) END SUBROUTINE DSPGST END INTERFACE INTERFACE LA_BDSQR SUBROUTINE DBDSQR( UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, & & LDU, C, LDC, RWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDC, LDU, LDVT, N, NCC, NCVT, NRU INTEGER, INTENT(OUT) :: INFO REAL, INTENT(INOUT) :: D(*), E(*) REAL, INTENT(OUT) :: RWORK(*) REAL(WP), INTENT(INOUT) :: C(LDC,*), U(LDU,*), VT(LDVT,*) END SUBROUTINE DBDSQR END INTERFACE INTERFACE LA_ORMBR SUBROUTINE DORMBR( VECT, SIDE, TRANS, M, N, K, A, LDA, TAU, C, & & LDC, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS, VECT INTEGER, INTENT(IN) :: K, LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*), TAU(*) REAL(WP), INTENT(INOUT) :: C(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORMBR END INTERFACE INTERFACE LA_ORGBR SUBROUTINE DORGBR( VECT, M, N, K, A, LDA, TAU, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: VECT INTEGER, INTENT(IN) :: K, LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: TAU(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORGBR END INTERFACE INTERFACE LA_GBBRD SUBROUTINE DGBBRD( VECT, M, N, NCC, KL, KU, AB, LDAB, D, E, Q, & & LDQ, PT, LDPT, C, LDC, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: VECT INTEGER, INTENT(IN) :: KL, KU, LDAB, LDC, LDPT, LDQ, M, N, NCC INTEGER, INTENT(OUT) :: INFO REAL, INTENT(OUT) :: D(*), E(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*), C(LDC,*) REAL(WP), INTENT(OUT) :: PT(LDPT,*), Q(LDQ,*), WORK(*) END SUBROUTINE DGBBRD END INTERFACE INTERFACE LA_GEBRD SUBROUTINE DGEBRD( M, N, A, LDA, D, E, TAUQ, TAUP, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: D(*), E(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAUP(*), TAUQ(*), WORK(LWORK) END SUBROUTINE DGEBRD END INTERFACE INTERFACE LA_TRSEN SUBROUTINE DTRSEN( JOB, COMPQ, SELECT, N, T, LDT, Q, LDQ, WR, WI, & & M, S, SEP, WORK, LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPQ, JOB INTEGER, INTENT(IN) :: LDQ, LDT, LWORK, N, LIWORK INTEGER, INTENT(OUT) :: INFO, M, IWORK(LIWORK) REAL(WP), INTENT(OUT) :: S, SEP LOGICAL, INTENT(IN) :: SELECT(*) REAL(WP), INTENT(INOUT) :: Q(LDQ,*), T(LDT,*) REAL(WP), INTENT(IN) :: WR(*), WI(*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DTRSEN END INTERFACE INTERFACE LA_TRSNA SUBROUTINE DTRSNA( JOB, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR, & & LDVR, S, SEP, MM, M, WORK, LDWORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: HOWMNY, JOB INTEGER, INTENT(IN) :: LDT, LDVL, LDVR, LDWORK, MM, N INTEGER, INTENT(OUT) :: INFO, M, IWORK(*) LOGICAL, INTENT(IN) :: SELECT(*) REAL(WP), INTENT(OUT) :: S(*), SEP(*) REAL(WP), INTENT(IN) :: T(LDT,*), VL(LDVL,*), VR(LDVR,*) REAL(WP), INTENT(OUT) :: WORK(LDWORK,*) END SUBROUTINE DTRSNA END INTERFACE INTERFACE LA_TRSYL SUBROUTINE DTRSYL( TRANA, TRANB, ISGN, M, N, A, LDA, B, LDB, C, & & LDC, SCALE, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANA, TRANB INTEGER, INTENT(IN) :: ISGN, LDA, LDB, LDC, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: SCALE REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(INOUT) :: C(LDC,*) END SUBROUTINE DTRSYL END INTERFACE INTERFACE LA_TREXC SUBROUTINE DTREXC( COMPQ, N, T, LDT, Q, LDQ, IFST, ILST, WORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPQ INTEGER, INTENT(IN) :: IFST, ILST, LDQ, LDT, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: Q(LDQ,*), T(LDT,*), WORK(*) END SUBROUTINE DTREXC END INTERFACE INTERFACE LA_TREVC SUBROUTINE DTREVC( SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR, & & LDVR, MM, M, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: HOWMNY, SIDE INTEGER, INTENT(IN) :: LDT, LDVL, LDVR, MM, N INTEGER, INTENT(OUT) :: INFO, M LOGICAL, INTENT(INOUT) :: SELECT(*) REAL(WP), INTENT(IN) :: T(LDT,*) REAL(WP), INTENT(INOUT) :: VL(LDVL,*), VR(LDVR,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTREVC END INTERFACE INTERFACE LA_HSEIN SUBROUTINE DHSEIN( SIDE, EIGSRC, INITV, SELECT, N, H, LDH, WR, WI,& & VL, LDVL, VR, LDVR, MM, M, WORK, IFAILL, & & IFAILR, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: EIGSRC, INITV, SIDE INTEGER, INTENT(IN) :: LDH, LDVL, LDVR, MM, N INTEGER, INTENT(OUT) :: INFO, M, IFAILL(*), IFAILR(*) LOGICAL, INTENT(IN) :: SELECT(*) REAL(WP), INTENT(INOUT) :: WR(*), WI(*) REAL(WP), INTENT(IN) :: H(LDH,*) REAL(WP), INTENT(INOUT) :: VL(LDVL,*), VR(LDVR,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DHSEIN END INTERFACE INTERFACE LA_HSEQR SUBROUTINE DHSEQR( JOB, COMPZ, N, ILO, IHI, H, LDH, WR, WI, Z, & & LDZ, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPZ, JOB INTEGER, INTENT(IN) :: IHI, ILO, LDH, LDZ, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: WR(*), WI(*) REAL(WP), INTENT(INOUT) :: H(LDH,*), Z(LDZ,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DHSEQR END INTERFACE INTERFACE LA_ORMHR SUBROUTINE DORMHR( SIDE, TRANS, M, N, ILO, IHI, A, LDA, TAU, C, & & LDC, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS INTEGER, INTENT(IN) :: IHI, ILO, LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*), TAU(*) REAL(WP), INTENT(INOUT) :: C(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORMHR END INTERFACE INTERFACE LA_ORGHR SUBROUTINE DORGHR( N, ILO, IHI, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: IHI, ILO, LDA, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: TAU(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORGHR END INTERFACE INTERFACE LA_GEBAK SUBROUTINE DGEBAK( JOB, SIDE, N, ILO, IHI, SCALE, M, V, LDV, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOB, SIDE INTEGER, INTENT(IN) :: IHI, ILO, LDV, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: SCALE(*) REAL(WP), INTENT(INOUT) :: V(LDV,*) END SUBROUTINE DGEBAK END INTERFACE INTERFACE LA_GEBAL SUBROUTINE DGEBAL( JOB, N, A, LDA, ILO, IHI, SCALE, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOB INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: IHI, ILO, INFO REAL(WP), INTENT(OUT) :: SCALE(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) END SUBROUTINE DGEBAL END INTERFACE INTERFACE LA_GEHRD SUBROUTINE DGEHRD( N, ILO, IHI, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: IHI, ILO, LDA, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(LWORK) END SUBROUTINE DGEHRD END INTERFACE INTERFACE LA_PTEQR SUBROUTINE DPTEQR( COMPZ, N, D, E, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPZ INTEGER, INTENT(IN) :: INFO, LDZ, N REAL(WP), INTENT(INOUT) :: D(*), E(*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(INOUT) :: Z(LDZ,*) END SUBROUTINE DPTEQR END INTERFACE INTERFACE LA_STEIN SUBROUTINE DSTEIN( N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, & & IWORK, IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDZ, M, N, IBLOCK(*), ISPLIT(*) INTEGER, INTENT(OUT) :: INFO, IFAIL(*), IWORK(*) REAL(WP), INTENT(IN) :: D(*), E(*), W(*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(OUT) :: Z( LDZ, * ) END SUBROUTINE DSTEIN END INTERFACE INTERFACE LA_STEBZ SUBROUTINE DSTEBZ( RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E, & & M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: ORDER, RANGE INTEGER, INTENT(IN) :: IL, IU, M, N INTEGER, INTENT(OUT) :: INFO, NSPLIT, IBLOCK(*), ISPLIT(*), & & IWORK(*) REAL(WP), INTENT(IN) :: ABSTOL, VL, VU, D(*), E(*) REAL(WP), INTENT(OUT) :: W(*), WORK(*) END SUBROUTINE DSTEBZ END INTERFACE INTERFACE LA_STEDC SUBROUTINE DSTEDC( COMPZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, & & LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPZ INTEGER, INTENT(IN) :: LDZ, LIWORK, LWORK, N INTEGER, INTENT(OUT) :: INFO, IWORK(LIWORK) REAL(WP), INTENT(INOUT) :: D(*), E(*) REAL(WP), INTENT(INOUT) :: Z(LDZ,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DSTEDC END INTERFACE INTERFACE LA_STERF SUBROUTINE DSTERF( N, D, E, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*), E(*) END SUBROUTINE DSTERF END INTERFACE INTERFACE LA_STEQR SUBROUTINE DSTEQR( COMPZ, N, D, E, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: COMPZ INTEGER, INTENT(IN) :: LDZ, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*), E(*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(INOUT) :: Z(LDZ,*) END SUBROUTINE DSTEQR END INTERFACE INTERFACE LA_OPMTR SUBROUTINE DOPMTR( SIDE, UPLO, TRANS, M, N, AP, TAU, C, LDC, WORK,& & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS, UPLO INTEGER, INTENT(IN) :: LDC, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*), TAU(*) REAL(WP), INTENT(INOUT) :: C(LDC,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DOPMTR END INTERFACE INTERFACE LA_OPGTR SUBROUTINE DOPGTR( UPLO, N, AP, TAU, Q, LDQ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDQ, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*), TAU(*) REAL(WP), INTENT(OUT) :: Q(LDQ,*), WORK(*) END SUBROUTINE DOPGTR END INTERFACE INTERFACE LA_ORMTR SUBROUTINE DORMTR( SIDE, UPLO, TRANS, M, N, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS, UPLO INTEGER, INTENT(IN) :: LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*), TAU(*) REAL(WP), INTENT(OUT) :: WORK(LWORK) REAL(WP), INTENT(INOUT) :: C(LDC,*) END SUBROUTINE DORMTR END INTERFACE INTERFACE LA_SBTRD SUBROUTINE DSBTRD( VECT, UPLO, N, KD, AB, LDAB, D, E, Q, LDQ, & & WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, VECT INTEGER, INTENT(IN) :: KD, LDAB, LDQ, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: D(*), E(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*), Q(LDQ,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSBTRD END INTERFACE INTERFACE LA_SPTRD SUBROUTINE DSPTRD( UPLO, N, AP, D, E, TAU, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: D(*), E(*) REAL(WP), INTENT(INOUT) :: AP(*) REAL(WP), INTENT(OUT) :: TAU(*) END SUBROUTINE DSPTRD END INTERFACE INTERFACE LA_TZRQF SUBROUTINE DTZRQF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(LWORK) END SUBROUTINE DTZRQF END INTERFACE INTERFACE LA_ORMRQ SUBROUTINE DORMRQ( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS INTEGER, INTENT(IN) :: K, LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*), TAU(*) REAL(WP), INTENT(INOUT) :: C(LDC,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORMRQ END INTERFACE INTERFACE LA_ORGRQ SUBROUTINE DORGRQ( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: K, LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: TAU(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORGRQ END INTERFACE INTERFACE LA_GERQF SUBROUTINE DGERQF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(LWORK) END SUBROUTINE DGERQF END INTERFACE INTERFACE LA_ORMQL SUBROUTINE DORMQL( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS INTEGER, INTENT(IN) :: K, LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*), TAU(*) REAL(WP), INTENT(INOUT) :: C(LDC,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORMQL END INTERFACE INTERFACE LA_ORGQL SUBROUTINE DORGQL( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: K, LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: TAU(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORGQL END INTERFACE INTERFACE LA_GEQLF SUBROUTINE DGEQLF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(LWORK) END SUBROUTINE DGEQLF END INTERFACE INTERFACE LA_ORMLQ SUBROUTINE DORMLQ( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS INTEGER, INTENT(IN) :: K, LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*), TAU(*) REAL(WP), INTENT(INOUT) :: C(LDC,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORMLQ END INTERFACE INTERFACE LA_ORGLQ SUBROUTINE DORGLQ( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: K, LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: TAU(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORGLQ END INTERFACE INTERFACE LA_GELQF SUBROUTINE DGELQF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(LWORK) END SUBROUTINE DGELQF END INTERFACE INTERFACE LA_ORMQR SUBROUTINE DORMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: SIDE, TRANS INTEGER, INTENT(IN) :: K, LDA, LDC, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*), TAU(*) REAL(WP), INTENT(INOUT) :: C(LDC,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORMQR END INTERFACE INTERFACE LA_ORGQR SUBROUTINE DORGQR( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: K, LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(IN) :: TAU(*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORGQR END INTERFACE INTERFACE LA_GEQRF SUBROUTINE DGEQRF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(LWORK) END SUBROUTINE DGEQRF END INTERFACE INTERFACE LA_GEQPF SUBROUTINE DGEQPF( M, N, A, LDA, JPVT, TAU, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, M, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(INOUT) :: JPVT(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(*) END SUBROUTINE DGEQPF END INTERFACE INTERFACE LA_TBRFS SUBROUTINE DTBRFS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AB(LDAB,*), B(LDB,*), X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTBRFS MODULE PROCEDURE DTBRFS1 END INTERFACE INTERFACE LA_TBCON SUBROUTINE DTBCON( NORM, UPLO, DIAG, N, KD, AB, LDAB, RCOND, WORK,& & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, NORM, UPLO INTEGER, INTENT(IN) :: KD, LDAB, N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(IN) :: AB(LDAB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTBCON END INTERFACE INTERFACE LA_TBTRS SUBROUTINE DTBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AB(LDAB,*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DTBTRS MODULE PROCEDURE DTBTRS1 END INTERFACE INTERFACE LA_TPTRI SUBROUTINE DTPTRI( UPLO, DIAG, N, AP, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP( * ) END SUBROUTINE DTPTRI END INTERFACE INTERFACE LA_TPRFS SUBROUTINE DTPRFS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX,& & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AP(*), B(LDB,*), X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTPRFS MODULE PROCEDURE DTPRFS1 END INTERFACE INTERFACE LA_TPCON SUBROUTINE DTPCON( NORM, UPLO, DIAG, N, AP, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, NORM, UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTPCON END INTERFACE INTERFACE LA_TPTRS SUBROUTINE DTPTRS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DTPTRS MODULE PROCEDURE DTPTRS1 END INTERFACE INTERFACE LA_TRTRI SUBROUTINE DTRTRI( UPLO, DIAG, N, A, LDA, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A( LDA, * ) END SUBROUTINE DTRTRI END INTERFACE INTERFACE LA_TRRFS SUBROUTINE DTRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDA, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(IN) :: X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTRRFS MODULE PROCEDURE DTRRFS1 END INTERFACE INTERFACE LA_TRCON SUBROUTINE DTRCON( NORM, UPLO, DIAG, N, A, LDA, RCOND, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, NORM, UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(IN) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTRCON END INTERFACE INTERFACE LA_TRTRS SUBROUTINE DTRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DTRTRS MODULE PROCEDURE DTRTRS1 END INTERFACE INTERFACE LA_SPTRI SUBROUTINE DSPTRI( UPLO, N, AP, IPIV, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AP(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSPTRI END INTERFACE INTERFACE LA_SPRFS SUBROUTINE DSPRFS( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AFP(*), AP(*), B(LDB,*) REAL(WP), INTENT(INOUT) :: X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSPRFS MODULE PROCEDURE DSPRFS1 END INTERFACE INTERFACE LA_SPCON SUBROUTINE DSPCON( UPLO, N, AP, IPIV, ANORM, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND INTEGER, INTENT(IN) :: IPIV( * ) REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSPCON END INTERFACE INTERFACE LA_SPTRS SUBROUTINE DSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DSPTRS MODULE PROCEDURE DSPTRS1 END INTERFACE INTERFACE LA_SPTRF SUBROUTINE DSPTRF( UPLO, N, AP, IPIV, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO, IPIV(*) REAL(WP), INTENT(INOUT) :: AP(*) END SUBROUTINE DSPTRF END INTERFACE INTERFACE LA_SYTRI SUBROUTINE DSYTRI( UPLO, N, A, LDA, IPIV, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: A( LDA,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYTRI END INTERFACE INTERFACE LA_SYRFS SUBROUTINE DSYRFS( UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, & & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: A( LDA,*), AF( LDAF,*), B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYRFS MODULE PROCEDURE DSYRFS1 END INTERFACE INTERFACE LA_SYCON SUBROUTINE DSYCON( UPLO, N, A, LDA, IPIV, ANORM, RCOND, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: A( LDA,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYCON END INTERFACE INTERFACE LA_SYTRS SUBROUTINE DSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER , INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: A( LDA,*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DSYTRS MODULE PROCEDURE DSYTRS1 END INTERFACE INTERFACE LA_SYTRF SUBROUTINE DSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LWORK, N INTEGER, INTENT(OUT) :: INFO, IPIV(*) REAL(WP), INTENT(INOUT) :: A( LDA,*) REAL(WP), INTENT(OUT) :: WORK( LWORK ) END SUBROUTINE DSYTRF END INTERFACE INTERFACE LA_PTRFS SUBROUTINE DPTRFS( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR, & & BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: D(*), DF(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: B( LDB,*), E(*), EF(*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPTRFS MODULE PROCEDURE DPTRFS1 END INTERFACE INTERFACE LA_PTCON SUBROUTINE DPTCON( N, D, E, ANORM, RCOND, RWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: ANORM, D(*) REAL(WP), INTENT(OUT) :: RCOND, RWORK(*) REAL(WP), INTENT(IN) :: E(*) END SUBROUTINE DPTCON END INTERFACE INTERFACE LA_PTTRS SUBROUTINE DPTTRS( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(IN) :: E(*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DPTTRS MODULE PROCEDURE DPTTRS1 END INTERFACE INTERFACE LA_PTTRF SUBROUTINE DPTTRF( N, D, E, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D( * ) REAL(WP), INTENT(INOUT) :: E( * ) END SUBROUTINE DPTTRF END INTERFACE INTERFACE LA_PBEQU SUBROUTINE DPBEQU( UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: AMAX, SCOND, S(*) REAL(WP), INTENT(IN) :: AB( LDAB,*) END SUBROUTINE DPBEQU END INTERFACE INTERFACE LA_PBRFS SUBROUTINE DPBRFS( UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDAFB, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AB( LDAB,*), AFB( LDAFB,*), B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPBRFS MODULE PROCEDURE DPBRFS1 END INTERFACE INTERFACE LA_PBCON SUBROUTINE DPBCON( UPLO, N, KD, AB, LDAB, ANORM, RCOND, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(IN) :: AB( LDAB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPBCON END INTERFACE INTERFACE LA_PBTRS SUBROUTINE DPBTRS( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AB( LDAB,*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DPBTRS MODULE PROCEDURE DPBTRS1 END INTERFACE INTERFACE LA_PBTRF SUBROUTINE DPBTRF( UPLO, N, KD, AB, LDAB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB( LDAB,*) END SUBROUTINE DPBTRF END INTERFACE INTERFACE LA_PPEQU SUBROUTINE DPPEQU( UPLO, N, AP, S, SCOND, AMAX, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: AMAX, SCOND, S(*) REAL(WP), INTENT(IN) :: AP(*) END SUBROUTINE DPPEQU END INTERFACE INTERFACE LA_PPTRI SUBROUTINE DPPTRI( UPLO, N, AP, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*) END SUBROUTINE DPPTRI END INTERFACE INTERFACE LA_PPRFS SUBROUTINE DPPRFS( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AFP(*), AP(*), B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPPRFS MODULE PROCEDURE DPPRFS1 END INTERFACE INTERFACE LA_PPCON SUBROUTINE DPPCON( UPLO, N, AP, ANORM, RCOND, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPPCON END INTERFACE INTERFACE LA_PPTRS SUBROUTINE DPPTRS( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DPPTRS MODULE PROCEDURE DPPTRS1 END INTERFACE INTERFACE LA_PPTRF SUBROUTINE DPPTRF( UPLO, N, AP, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*) END SUBROUTINE DPPTRF END INTERFACE INTERFACE LA_POEQU SUBROUTINE DPOEQU( N, A, LDA, S, SCOND, AMAX, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: AMAX, SCOND, S(*) REAL(WP), INTENT(IN) :: A( LDA,*) END SUBROUTINE DPOEQU END INTERFACE INTERFACE LA_POTRI SUBROUTINE DPOTRI( UPLO, N, A, LDA, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A( LDA,*) END SUBROUTINE DPOTRI END INTERFACE INTERFACE LA_PORFS SUBROUTINE DPORFS( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: A( LDA,*), AF( LDAF,*), B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPORFS MODULE PROCEDURE DPORFS1 END INTERFACE INTERFACE LA_POTRS SUBROUTINE DPOTRS( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A( LDA,*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DPOTRS MODULE PROCEDURE DPOTRS1 END INTERFACE INTERFACE LA_GTRFS SUBROUTINE DGTRFS( TRANS, N, NRHS, DL, D, DU, DLF, DF, DUF, DU2, & & IPIV, B, LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS, IPIV(*) INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: B( LDB,*), D(*), DF(*), DL(*), DLF(*), & & DU(*), DU2(*), DUF(*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGTRFS MODULE PROCEDURE DGTRFS1 END INTERFACE INTERFACE LA_GTCON SUBROUTINE DGTCON( NORM, N, DL, D, DU, DU2, IPIV, ANORM, RCOND, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: D(*), DL(*), DU(*), DU2(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGTCON END INTERFACE INTERFACE LA_GTTRS SUBROUTINE DGTTRS( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: D(*), DL(*), DU(*), DU2(*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DGTTRS MODULE PROCEDURE DGTTRS1 END INTERFACE INTERFACE LA_GTTRF SUBROUTINE DGTTRF( N, DL, D, DU, DU2, IPIV, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IPIV(*) REAL(WP), INTENT(INOUT) :: D(*), DL(*), DU(*) REAL(WP), INTENT(OUT) :: DU2(*) END SUBROUTINE DGTTRF END INTERFACE INTERFACE LA_GBEQU SUBROUTINE DGBEQU( M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, & & AMAX, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: KL, KU, LDAB, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: AMAX, COLCND, ROWCND REAL(WP), INTENT(OUT) :: C(*), R(*) REAL(WP), INTENT(IN) :: AB( LDAB,*) END SUBROUTINE DGBEQU END INTERFACE INTERFACE LA_GBRFS SUBROUTINE DGBRFS( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, & & IPIV, B, LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: KL, KU, LDAB, LDAFB, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AB( LDAB,*), AFB( LDAFB,*), B( LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(INOUT) :: X( LDX,*) END SUBROUTINE DGBRFS MODULE PROCEDURE DGBRFS1 END INTERFACE INTERFACE LA_GBCON SUBROUTINE DGBCON( NORM, N, KL, KU, AB, LDAB, IPIV, ANORM, RCOND, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: KL, KU, LDAB, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND INTEGER, INTENT(IN) :: IPIV( * ) INTEGER, INTENT(OUT) :: IWORK( * ) REAL(WP), INTENT(IN) :: AB( LDAB, * ) REAL(WP), INTENT(OUT) :: WORK( * ) END SUBROUTINE DGBCON END INTERFACE INTERFACE LA_GBTRS SUBROUTINE DGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB,& & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: KL, KU, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: AB( LDAB,*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DGBTRS MODULE PROCEDURE DGBTRS1 END INTERFACE INTERFACE LA_GBTRF SUBROUTINE DGBTRF( M, N, KL, KU, AB, LDAB, IPIV, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: KL, KU, LDAB, M, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*) END SUBROUTINE DGBTRF END INTERFACE INTERFACE FUNCTION DLAMCH( CMACH ) USE LA_PRECISION, ONLY: WP => DP REAL(WP) :: DLAMCH CHARACTER(LEN=1), INTENT(IN) :: CMACH END FUNCTION DLAMCH END INTERFACE INTERFACE LA_GGSVD SUBROUTINE DGGSVD( JOBU, JOBV, JOBQ, M, N, P, K, L, A, LDA, B, & & LDB, ALPHA, BETA, U, LDU, V, LDV, Q, LDQ, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBU, JOBV, JOBQ INTEGER, INTENT(IN) :: M, N, P, LDA, LDB, LDU, LDV, LDQ INTEGER, INTENT(OUT) :: INFO, K, L, IWORK(*) REAL(WP), INTENT(OUT) :: ALPHA(*), BETA(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: U(LDU,*), V(LDV,*), Q(LDQ,*), WORK(*) END SUBROUTINE DGGSVD END INTERFACE INTERFACE LA_GEGV SUBROUTINE DGEGV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, & & ALPHAI, BETA, VL, LDVL, VR, LDVR, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBVL, JOBVR INTEGER, INTENT(IN) :: LDA, LDB, N, LDVL, LDVR, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: ALPHAR(*), ALPHAI(*), BETA(*), & & VL(LDVL,*), VR(LDVR,*), WORK(*) END SUBROUTINE DGEGV END INTERFACE INTERFACE LA_GEGS SUBROUTINE DGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHAR, & & ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBVSL, JOBVSR INTEGER, INTENT(IN) :: LDA, LDB, N, LDVSL, LDVSR, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: ALPHAR(*), ALPHAI(*), BETA(*), & & VSL(LDVSL,*), VSR(LDVSR,*), WORK(*) END SUBROUTINE DGEGS END INTERFACE INTERFACE LA_SBGVX SUBROUTINE DSBGVX( JOBZ, RANGE, UPLO, N, KAB, KBB, AB, LDAB, BB, & & LDBB, Q, LDQ, VL, VU, IL, IU, ABSTOL, M, W, Z,& & LDZ, WORK, IWORK, IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE, UPLO INTEGER, INTENT(IN) :: N, IL, IU, KAB, KBB, LDAB, LDBB, LDQ, LDZ INTEGER, INTENT(OUT) :: M REAL(WP), INTENT(IN) :: ABSTOL, VL, VU INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB(LDAB,*), BB(LDBB,*) REAL(WP), INTENT(OUT) :: WORK(*), Q(LDQ,*), Z(LDZ,*) REAL(WP), INTENT(OUT) :: W(*) INTEGER, INTENT(IN) :: IFAIL(*) END SUBROUTINE DSBGVX END INTERFACE INTERFACE LA_SBGVD SUBROUTINE DSBGVD( JOBZ, UPLO, N, KAB, KBB, AB, LDAB, BB, LDBB, & & W, Z, LDZ, WORK, LWORK, IWORK, LIWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: N, KAB, KBB, LDAB, LDBB, LDZ INTEGER, INTENT(IN) :: LWORK, LIWORK INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*), BB(LDBB,*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: Z(LDZ,*), WORK(*) END SUBROUTINE DSBGVD END INTERFACE INTERFACE LA_SBGV SUBROUTINE DSBGV( JOBZ, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, W, & & Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: KA, KB, LDAB, LDBB, N, LDZ INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*), BB(LDBB,*) REAL(WP), INTENT(OUT) :: Z(LDZ,*), WORK(*) END SUBROUTINE DSBGV END INTERFACE INTERFACE LA_SPGVX SUBROUTINE DSPGVX( ITYPE, JOBZ, RANGE, UPLO, N, AP, BP, VL, VU, & & IL, IU, ABSTOL, M, W, Z, LDZ, WORK, IWORK, & & IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE, UPLO INTEGER, INTENT(IN) :: ITYPE, N, IL, IU, LDZ INTEGER, INTENT(OUT) :: M REAL(WP), INTENT(IN) :: ABSTOL, VL, VU INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*), BP(*) REAL(WP), INTENT(OUT) :: WORK(*), Z(LDZ,*) REAL(WP), INTENT(OUT) :: W(*) INTEGER, INTENT(IN) :: IFAIL(*) END SUBROUTINE DSPGVX END INTERFACE INTERFACE LA_SPGVD SUBROUTINE DSPGVD( ITYPE, JOBZ, UPLO, N, AP, BP, W, Z, LDZ, & & WORK, LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: ITYPE, N, LDZ INTEGER, INTENT(IN) :: LWORK, LIWORK INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(INOUT) :: AP(*), BP(*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: Z(LDZ,*), WORK(*) END SUBROUTINE DSPGVD END INTERFACE INTERFACE LA_SPGV SUBROUTINE DSPGV( ITYPE, JOBZ, UPLO, N, AP, BP, W, Z, LDZ, WORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: ITYPE, N, LDZ INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(INOUT) :: AP(*), BP(*) REAL(WP), INTENT(OUT) :: Z(LDZ,*), WORK(*) END SUBROUTINE DSPGV END INTERFACE INTERFACE LA_GESVD SUBROUTINE DGESVD( JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT, & & LDVT, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBU, JOBVT INTEGER, INTENT(IN) :: M, N, LDA, LDU, LDVT, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: U(LDU,*), VT(LDVT,*), WORK(*) END SUBROUTINE DGESVD END INTERFACE INTERFACE LA_GEEVX SUBROUTINE DGEEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, WR, & & WI, VL, LDVL, VR, LDVR, ILO, IHI, SCALE, & & ABNRM, RCONDE, RCONDV, WORK, LWORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: BALANC, JOBVL, JOBVR, SENSE INTEGER, INTENT(IN) :: N, LDA, LDVL, LDVR, LWORK INTEGER, INTENT(OUT) :: INFO, ILO, IHI, IWORK(*) REAL(WP), INTENT(OUT) :: ABNRM REAL(WP), INTENT(OUT) :: SCALE(*), RCONDE(*), RCONDV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: VL(LDVL,*), VR(LDVR,*), WR(*), WI(*), & & WORK(*) END SUBROUTINE DGEEVX END INTERFACE INTERFACE LA_GGEVX SUBROUTINE DGGEVX( BALANC, JOBVL, JOBVR, SENSE, N, A, LDA, B, & & LDB, ALPHAR, ALPHAI, BETA, VL, LDVL, VR, LDVR,& & ILO, IHI, LSCALE, RSCALE, ABNRM, BBNRM, & & RCONDE, RCONDV, WORK, LWORK, IWORK, BWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: BALANC, JOBVL, JOBVR, SENSE INTEGER, INTENT(IN) :: LDA, LDB, N, LDVL, LDVR, LWORK INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT):: ILO, IHI REAL(WP), INTENT(OUT) :: ABNRM, BBNRM REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: ALPHAR(*), ALPHAI(*), BETA(*), & & VL(LDVL,*), VR(LDVR,*), WORK(*), & & LSCALE(*), RSCALE(*), RCONDE(*), & & RCONDV(*) INTEGER :: IWORK(*) LOGICAL :: BWORK(*) END SUBROUTINE DGGEVX END INTERFACE INTERFACE LA_GGEV SUBROUTINE DGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, & & ALPHAI, BETA, VL, LDVL, VR, LDVR, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBVL, JOBVR INTEGER, INTENT(IN) :: LDA, LDB, N, LDVL, LDVR, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: ALPHAR(*), ALPHAI(*), BETA(*), & & VL(LDVL,*), VR(LDVR,*), WORK(*) END SUBROUTINE DGGEV END INTERFACE INTERFACE LA_GEEV SUBROUTINE DGEEV( JOBVL, JOBVR, N, A, LDA, WR, WI, VL, LDVL, VR, & & LDVR, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBVL, JOBVR INTEGER, INTENT(IN) :: N, LDA, LDVL, LDVR, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: VL(LDVL,*), VR(LDVR,*), WR(*), WI(*), & & WORK(*) END SUBROUTINE DGEEV END INTERFACE INTERFACE LA_GEESX SUBROUTINE DGEESX( JOBVS, SORT, SELECT, SENSE, N, A, LDA, SDIM, & & WR, WI, VS, LDVS, RCONDE, RCONDV, WORK, LWORK,& & IWORK, LIWORK, BWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTERFACE LOGICAL FUNCTION SELECT(WR, WI) USE LA_PRECISION, ONLY: WP => DP REAL(WP), INTENT(IN) :: WR, WI END FUNCTION SELECT END INTERFACE CHARACTER(LEN=1), INTENT(IN) :: JOBVS, SORT, SENSE INTEGER, INTENT(IN) :: N, LDA, LDVS, LWORK, LIWORK INTEGER, INTENT(OUT) :: INFO, SDIM, IWORK(*) LOGICAL, INTENT(OUT) :: BWORK(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: RCONDV, RCONDE REAL(WP), INTENT(OUT) :: VS(LDVS,*), WR(*), WI(*), WORK(*) OPTIONAL :: SELECT END SUBROUTINE DGEESX END INTERFACE INTERFACE LA_GGESX SUBROUTINE DGGESX( JOBVSL, JOBVSR, SORT, DELCTG, SENSE, N, A, & & LDA, B, LDB, SDIM, ALPHAR, ALPHAI, BETA, VSL, & & LDVSL, VSR, LDVSR, RCONDE, RCONDV, WORK, & & LWORK, IWORK, LIWORK, BWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBVSL, JOBVSR, SORT, SENSE INTEGER, INTENT(IN) :: LDA, LDB, N, LDVSL, LDVSR, LWORK, LIWORK INTEGER, INTENT(INOUT) :: INFO INTEGER, INTENT(OUT) :: SDIM REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: ALPHAR(*), ALPHAI(*), BETA(*), & & VSL(LDVSL,*), VSR(LDVSR,*), WORK(*) REAL(WP), INTENT(OUT) :: RCONDE(2), RCONDV(2) LOGICAL :: BWORK(*) INTEGER :: IWORK (*) INTERFACE LOGICAL FUNCTION DELCTG(ALPHAR, ALPHAI, BETA) USE LA_PRECISION, ONLY: WP => DP REAL(WP), INTENT(IN) :: ALPHAR, ALPHAI, BETA END FUNCTION DELCTG END INTERFACE OPTIONAL :: DELCTG END SUBROUTINE DGGESX END INTERFACE INTERFACE LA_GGES SUBROUTINE DGGES( JOBVSL, JOBVSR, SORT, DELCTG, N, A, LDA, B, & & LDB, SDIM, ALPHAR, ALPHAI, BETA, VSL, LDVSL, & & VSR, LDVSR, WORK, LWORK, BWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBVSL, JOBVSR, SORT INTEGER, INTENT(IN) :: LDA, LDB, N, LDVSL, LDVSR, LWORK INTEGER, INTENT(INOUT) :: INFO INTEGER, INTENT(OUT) :: SDIM REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: ALPHAR(*), ALPHAI(*), BETA(*), & & VSL(LDVSL,*), VSR(LDVSR,*), WORK(*) LOGICAL :: BWORK(*) INTERFACE LOGICAL FUNCTION DELCTG(ALPHAR, ALPHAI, BETA) USE LA_PRECISION, ONLY: WP => DP REAL(WP), INTENT(IN) :: ALPHAR, ALPHAI, BETA END FUNCTION DELCTG END INTERFACE OPTIONAL :: DELCTG END SUBROUTINE DGGES END INTERFACE INTERFACE LA_GEES SUBROUTINE DGEES( JOBVS, SORT, SELECT, N, A, LDA, SDIM, WR, WI, & & VS, LDVS, WORK, LWORK, BWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTERFACE LOGICAL FUNCTION SELECT(WR, WI) USE LA_PRECISION, ONLY: WP => DP REAL(WP), INTENT(IN) :: WR, WI END FUNCTION SELECT END INTERFACE CHARACTER(LEN=1), INTENT(IN) :: JOBVS, SORT INTEGER, INTENT(IN) :: N, LDA, LDVS, LWORK INTEGER, INTENT(OUT) :: INFO, SDIM LOGICAL, INTENT(OUT) :: BWORK(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: VS(LDVS,*), WR(*), WI(*), WORK(*) OPTIONAL :: SELECT END SUBROUTINE DGEES END INTERFACE INTERFACE LA_STEVR SUBROUTINE DSTEVR( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL, & & M, W, Z, LDZ, ISUPPZ, WORK, LWORK, IWORK, & & LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE INTEGER, INTENT(IN) :: N, IL, IU, LDZ, LWORK, LIWORK INTEGER, INTENT(OUT) :: M INTEGER, INTENT(OUT), TARGET :: ISUPPZ(*) REAL(WP), INTENT(IN) :: ABSTOL, VL, VU INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*), E(*) REAL(WP), INTENT(OUT) :: WORK(*), W(*) REAL(WP), INTENT(OUT), TARGET :: Z(LDZ,*) END SUBROUTINE DSTEVR END INTERFACE INTERFACE LA_STEVX SUBROUTINE DSTEVX( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL, & & M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE INTEGER, INTENT(IN) :: LDZ, N, IL, IU INTEGER, INTENT(OUT) :: INFO, IWORK(*), M, IFAIL(*) REAL(WP), INTENT(IN) :: VL, VU, ABSTOL REAL(WP), INTENT(INOUT) :: D(*), E(*) REAL(WP), INTENT(OUT) :: W(*), Z(LDZ,*), WORK(*) END SUBROUTINE DSTEVX END INTERFACE INTERFACE LA_STEVD SUBROUTINE DSTEVD( JOBZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, & & LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ INTEGER, INTENT(IN) :: LDZ, N, LWORK, LIWORK INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(INOUT) :: D(*), E(*) REAL(WP), INTENT(OUT) :: Z(LDZ,*), WORK(*) END SUBROUTINE DSTEVD END INTERFACE INTERFACE LA_STEV SUBROUTINE DSTEV( JOBZ, N, D, E, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ INTEGER, INTENT(IN) :: LDZ, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*), E(*) REAL(WP), INTENT(OUT) :: Z(LDZ,*), WORK(*) END SUBROUTINE DSTEV END INTERFACE INTERFACE LA_SBEVX SUBROUTINE DSBEVX( JOBZ, RANGE, UPLO, N, KD, AB, LDAB, Q, LDQ, & & VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, & & IWORK, IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO, RANGE INTEGER, INTENT(IN) :: LDZ, N, IL, IU, LDQ, KD, LDAB INTEGER, INTENT(OUT) :: INFO, IWORK(*), M, IFAIL(*) REAL(WP), INTENT(IN) :: VL, VU, ABSTOL REAL(WP), INTENT(INOUT) :: AB(LDAB,*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: Q(LDQ,*), Z(LDZ,*), WORK(*) END SUBROUTINE DSBEVX END INTERFACE INTERFACE LA_SBEVD SUBROUTINE DSBEVD( JOBZ, UPLO, N, KD, AB, LDAB, W, Z, LDZ, WORK, & & LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: N, KD, LDAB, LDZ, LWORK, LIWORK INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: Z(LDZ,*), WORK(*) END SUBROUTINE DSBEVD END INTERFACE INTERFACE LA_SBEV SUBROUTINE DSBEV( JOBZ, UPLO, N, KD, AB, LDAB, W, Z, LDZ, WORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: N, KD, LDAB, LDZ INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB(LDAB,*) REAL(WP), INTENT(OUT) :: W(*), Z(LDZ,*), WORK(*) END SUBROUTINE DSBEV END INTERFACE INTERFACE LA_SPEVX SUBROUTINE DSPEVX( JOBZ, RANGE, UPLO, N, AP, VL, VU, IL, IU, & & ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO, RANGE INTEGER, INTENT(IN) :: LDZ, N, IL, IU INTEGER, INTENT(OUT) :: INFO, IWORK(*), M, IFAIL(*) REAL(WP), INTENT(IN) :: VL, VU, ABSTOL REAL(WP), INTENT(INOUT) :: AP(*) REAL(WP), INTENT(OUT) :: W(*), Z(LDZ,*), WORK(*) END SUBROUTINE DSPEVX END INTERFACE INTERFACE LA_SPEVD SUBROUTINE DSPEVD( JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, LWORK, & & IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: LDZ, N, LWORK, LIWORK INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(INOUT) :: AP(*) REAL(WP), INTENT(OUT) :: W(*), Z(LDZ,*), WORK(*) END SUBROUTINE DSPEVD END INTERFACE INTERFACE LA_SPEV SUBROUTINE DSPEV( JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: LDZ, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*) REAL(WP), INTENT(OUT) :: W(*), Z(LDZ,*), WORK(*) END SUBROUTINE DSPEV END INTERFACE INTERFACE LA_GGGLM SUBROUTINE DGGGLM( N, M, P, A, LDA, B, LDB, D, X, Y, WORK, LWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: P, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*), D(*) REAL(WP), INTENT(OUT) :: WORK(*), X(*), Y(*) END SUBROUTINE DGGGLM END INTERFACE INTERFACE LA_GGLSE SUBROUTINE DGGLSE( M, N, P, A, LDA, B, LDB, C, D, X, WORK, LWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: P, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*), C(*), D(*) REAL(WP), INTENT(OUT) :: WORK(*), X(*) END SUBROUTINE DGGLSE END INTERFACE INTERFACE LA_GELSY SUBROUTINE DGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: M, N, NRHS, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK INTEGER, INTENT(INOUT) :: JPVT(*) REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELSY MODULE PROCEDURE DGELSY1 END INTERFACE INTERFACE LA_GELSD SUBROUTINE DGELSD( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(OUT) :: WORK(*) INTEGER :: IWORK(*) END SUBROUTINE DGELSD MODULE PROCEDURE DGELSD1 END INTERFACE INTERFACE LA_GELSX SUBROUTINE DGELSX( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK,& & WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB INTEGER, INTENT(OUT) :: INFO, RANK INTEGER, INTENT(INOUT) :: JPVT(*) REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELSX MODULE PROCEDURE DGELSX1 END INTERFACE INTERFACE LA_GELSS SUBROUTINE DGELSS( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELSS MODULE PROCEDURE DGELSS1 END INTERFACE INTERFACE LA_GELS SUBROUTINE DGELS( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, LWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELS MODULE PROCEDURE DGELS1 END INTERFACE INTERFACE LA_SPSV SUBROUTINE DSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AP(*), B(LDB,*) END SUBROUTINE DSPSV MODULE PROCEDURE DSPSV1 END INTERFACE INTERFACE LA_SYSV SUBROUTINE DSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYSV MODULE PROCEDURE DSYSV1 END INTERFACE INTERFACE LA_PTSV SUBROUTINE DPTSV( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*) REAL(WP), INTENT(INOUT) :: E(*), B(LDB,*) END SUBROUTINE DPTSV MODULE PROCEDURE DPTSV1 END INTERFACE INTERFACE LA_PBSV SUBROUTINE DPBSV( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB, KD, LDAB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB(LDAB,*), B(LDB,*) END SUBROUTINE DPBSV MODULE PROCEDURE DPBSV1 END INTERFACE INTERFACE LA_PPSV SUBROUTINE DPPSV( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*), B(LDB,*) END SUBROUTINE DPPSV MODULE PROCEDURE DPPSV1 END INTERFACE INTERFACE LA_POSV SUBROUTINE DPOSV( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB, LDA INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) END SUBROUTINE DPOSV MODULE PROCEDURE DPOSV1 END INTERFACE INTERFACE LA_GTSV SUBROUTINE DGTSV( N, NRHS, DL, D, DU, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: DL(*), D(*), DU(*), B(LDB,*) END SUBROUTINE DGTSV MODULE PROCEDURE DGTSV1 END INTERFACE INTERFACE LA_GBSV SUBROUTINE DGBSV( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: KL, KU, LDAB, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: PIV(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*), B(LDB,*) END SUBROUTINE DGBSV MODULE PROCEDURE DGBSV1 END INTERFACE INTERFACE LA_GESV SUBROUTINE DGESV( N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: PIV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) END SUBROUTINE DGESV MODULE PROCEDURE DGESV1 END INTERFACE INTERFACE LA_SPSVX SUBROUTINE DSPSVX( FACT, UPLO, N, NRHS, A, AF, IPIV, B, LDB, X, & & LDX, RCOND, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: A(*), B(LDB,*) REAL(WP), INTENT(INOUT) :: AF(*) END SUBROUTINE DSPSVX MODULE PROCEDURE DSPSVX1 END INTERFACE INTERFACE LA_SYSVX SUBROUTINE DSYSVX( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, & & B, LDB, X, LDX, RCOND, FERR, BERR, WORK, & & LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, FACT INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N, LWORK INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(INOUT) :: AF(LDAF,*) END SUBROUTINE DSYSVX MODULE PROCEDURE DSYSVX1 END INTERFACE INTERFACE LA_PTSVX SUBROUTINE DPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & RCOND, FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(IN) :: E(*), B(LDB,*) REAL(WP), INTENT(INOUT) :: DF(*) REAL(WP), INTENT(INOUT) :: EF(*) END SUBROUTINE DPTSVX MODULE PROCEDURE DPTSVX1 END INTERFACE INTERFACE LA_PBSVX SUBROUTINE DPBSVX( FACT, UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB,& & EQUED, S, B, LDB, X, LDX, RCOND, FERR, BERR, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDAB, LDAFB, LDB, LDX, NRHS, N, KD INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*), FERR(*), BERR(*), & & RCOND REAL(WP), INTENT(INOUT) :: AB(LDAB,*), AFB(LDAFB,*), B(LDB,*), & & S(*) END SUBROUTINE DPBSVX MODULE PROCEDURE DPBSVX1 END INTERFACE INTERFACE LA_PPSVX SUBROUTINE DPPSVX( FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B, & & LDB, X, LDX, RCOND, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: AP(*), AFP(*), B(LDB,*), S(*) END SUBROUTINE DPPSVX MODULE PROCEDURE DPPSVX1 END INTERFACE INTERFACE LA_POSVX SUBROUTINE DPOSVX( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, EQUED, & & S, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: S(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(LDB,*) END SUBROUTINE DPOSVX MODULE PROCEDURE DPOSVX1 END INTERFACE INTERFACE LA_GTSVX SUBROUTINE DGTSVX( FACT, TRANS, N, NRHS, DL, D, DU, DLF, DF, DUF,& & DU2, IPIV, B, LDB, X, LDX, RCOND, FERR, BERR, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*), X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: B(LDB,*), DL(*), D(*), DU(*) REAL(WP), INTENT(INOUT) :: DF(*), DLF(*), DU2(*), DUF(*) END SUBROUTINE DGTSVX MODULE PROCEDURE DGTSVX1 END INTERFACE INTERFACE LA_GBSVX SUBROUTINE DGBSVX( FACT, TRANS, N, KL, KU, NRHS, A, LDA, AF, & & LDAF, PIV, EQUED, R, C, B, LDB, X, LDX, RCOND,& & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N, KL, KU INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: PIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: R(*), C(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(LDB,*) END SUBROUTINE DGBSVX MODULE PROCEDURE DGBSVX1 END INTERFACE INTERFACE LA_GESVX SUBROUTINE DGESVX( FACT, TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, & & EQUED, R, C, B, LDB, X, LDX, RCOND, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: PIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: R(*), C(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(LDB,*) END SUBROUTINE DGESVX MODULE PROCEDURE DGESVX1 END INTERFACE INTERFACE LA_GETRF SUBROUTINE DGETRF( M, N, A, LDA, PIV, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, M, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT( OUT ) :: PIV( * ) REAL(WP), INTENT( INOUT ) :: A( LDA, * ) END SUBROUTINE DGETRF END INTERFACE INTERFACE LA_GETRS SUBROUTINE DGETRS( TRANS, N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDA, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: PIV(*) REAL(WP), INTENT(IN) :: A(LDA,*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DGETRS MODULE PROCEDURE DGETRS1 END INTERFACE INTERFACE LA_GETRI SUBROUTINE DGETRI( N, A, LDA, IPIV, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LWORK, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(OUT) :: WORK(LWORK) REAL(WP), INTENT(INOUT) :: A(LDA,*) END SUBROUTINE DGETRI END INTERFACE INTERFACE LA_GERFS SUBROUTINE DGERFS( TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, B, LDB,& & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: PIV(*) INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(IN) :: A(LDA,*), AF(LDAF,*), B(LDB,*) REAL(WP), INTENT(INOUT) :: X(LDX,*) END SUBROUTINE DGERFS MODULE PROCEDURE DGERFS1 END INTERFACE INTERFACE LA_GEEQU SUBROUTINE DGEEQU( M, N, A, LDA, R, C, ROWCND, COLCND, AMAX, & & INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, M, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: AMAX, COLCND, ROWCND REAL(WP), INTENT(IN) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: C( * ), R( * ) END SUBROUTINE DGEEQU END INTERFACE INTERFACE LA_LANGE FUNCTION DLANGE( NORM, M, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => DP REAL(WP) :: DLANGE CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: LDA, M, N REAL(WP), INTENT(IN) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: WORK( * ) END FUNCTION DLANGE MODULE PROCEDURE DLANGE1 END INTERFACE INTERFACE LA_GECON SUBROUTINE DGECON( NORM, N, A, LDA, ANORM, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND INTEGER, INTENT(OUT) :: IWORK( * ) REAL(WP), INTENT(IN) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: WORK( * ) END SUBROUTINE DGECON END INTERFACE INTERFACE LA_SYEV SUBROUTINE DSYEV( JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: LDA, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYEV END INTERFACE INTERFACE LA_SYEVD SUBROUTINE DSYEVD( JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, IWORK, & & LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: LDA, LIWORK, LWORK, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYEVD END INTERFACE INTERFACE LA_SYEVR SUBROUTINE DSYEVR( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, & & ABSTOL, M, W, Z, LDZ, ISUPPZ, WORK, LWORK, & & IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE, UPLO INTEGER, INTENT(IN) :: N, IL, IU, LDZ, LDA, LWORK, LIWORK INTEGER, INTENT(OUT) :: M INTEGER, INTENT(OUT) :: ISUPPZ(*) REAL(WP), INTENT(IN) :: ABSTOL, VL, VU INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(*), Z(LDZ,*) REAL(WP), INTENT(OUT) :: W(*) END SUBROUTINE DSYEVR END INTERFACE INTERFACE LA_SYEVX SUBROUTINE DSYEVX( JOBZ, RANGE, UPLO, N, A, LDA, VL, VU, IL, IU, & & ABSTOL, M, W, Z, LDZ, WORK, LWORK, IWORK, & & IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE, UPLO INTEGER, INTENT(IN) :: IL, IU, LDA, LDZ, LWORK, N INTEGER, INTENT(OUT) :: INFO, M INTEGER, INTENT(OUT) :: IFAIL(*), IWORK(*) REAL(WP), INTENT(IN) :: ABSTOL, VL, VU REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: WORK(*), Z(LDZ,*) END SUBROUTINE DSYEVX END INTERFACE INTERFACE LA_SYGST SUBROUTINE DSYGST( ITYPE, UPLO, N, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: ITYPE, LDA, LDB, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: B(LDB,*) REAL(WP), INTENT(INOUT) :: A(LDA,*) END SUBROUTINE DSYGST END INTERFACE INTERFACE LA_SYGV SUBROUTINE DSYGV( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: ITYPE, LDA, LDB, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYGV END INTERFACE INTERFACE LA_SYGVX SUBROUTINE DSYGVX( ITYPE, JOBZ, RANGE, UPLO, N, A, LDA, B, LDB, & & VL, VU, IL, IU, ABSTOL, M, W, Z, LDZ, WORK, & & LWORK, IWORK, IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, RANGE, UPLO INTEGER, INTENT(IN) :: ITYPE, N, IL, IU, LDZ, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: M REAL(WP), INTENT(IN) :: ABSTOL, VL, VU INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*), Z(LDZ,*) REAL(WP), INTENT(OUT) :: W(*) INTEGER, INTENT(IN) :: IFAIL(*) END SUBROUTINE DSYGVX END INTERFACE INTERFACE LA_SYGVD SUBROUTINE DSYGVD( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK,& & LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: JOBZ, UPLO INTEGER, INTENT(IN) :: ITYPE, N, LDA, LDB, LWORK, LIWORK INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: W(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYGVD END INTERFACE INTERFACE LA_SYTRD SUBROUTINE DSYTRD( UPLO, N, A, LDA, D, E, TAU, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: D(*), E(*) REAL(WP), INTENT(OUT) :: TAU(*), WORK(LWORK) END SUBROUTINE DSYTRD END INTERFACE INTERFACE LA_ORGTR SUBROUTINE DORGTR( UPLO, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LWORK, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: TAU(*) REAL(WP), INTENT(INOUT) :: A(LDA,*) REAL(WP), INTENT(OUT) :: WORK(LWORK) END SUBROUTINE DORGTR END INTERFACE INTERFACE LA_LANSY FUNCTION DLANSY( NORM, UPLO, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => DP REAL(WP) :: DLANSY CHARACTER(LEN=1), INTENT(IN) :: NORM, UPLO INTEGER, INTENT(IN) :: LDA, N REAL(WP), INTENT(IN) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: WORK( * ) END FUNCTION DLANSY END INTERFACE INTERFACE LA_POTRF SUBROUTINE DPOTRF( UPLO, N, A, LDA, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) END SUBROUTINE DPOTRF END INTERFACE INTERFACE LA_POCON SUBROUTINE DPOCON( UPLO, N, A, LDA, ANORM, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: ANORM REAL(WP), INTENT(OUT) :: RCOND INTEGER, INTENT(OUT) :: IWORK( * ) REAL(WP), INTENT(IN) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: WORK( * ) END SUBROUTINE DPOCON END INTERFACE INTERFACE LA_ILAENV FUNCTION ILAENV( ISPEC, NAME, OPTS, N1, N2, N3, N4 ) INTEGER :: ILAENV CHARACTER(LEN=*), INTENT(IN) :: NAME, OPTS INTEGER, INTENT(IN) :: ISPEC, N1, N2, N3, N4 END FUNCTION ILAENV END INTERFACE INTERFACE LA_LAGGE SUBROUTINE DLAGGE( M, N, KL, KU, D, A, LDA, ISEED, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: M, N, KL, KU, LDA INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(INOUT) :: ISEED(4) REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(OUT) :: A(LDA,*), WORK(*) END SUBROUTINE DLAGGE END INTERFACE CONTAINS SUBROUTINE DGESV1( N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: PIV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) INTERFACE SUBROUTINE DGESV( N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDA, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: PIV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) END SUBROUTINE DGESV END INTERFACE CALL DGESV( N, NRHS, A, LDA, PIV, B, LDB, INFO ) END SUBROUTINE DGESV1 SUBROUTINE DGESVX1( FACT, TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, & & EQUED, R, C, B, LDB, X, LDX, RCOND, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: PIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: X(*), WORK(*) REAL(WP), INTENT(INOUT) :: R(*), C(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(*) INTERFACE SUBROUTINE DGESVX( FACT, TRANS, N, NRHS, A, LDA, AF, LDAF, & & PIV, EQUED, R, C, B, LDB, X, LDX, RCOND, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: PIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: R(*), C(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(LDB,*) END SUBROUTINE DGESVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DGESVX( FACT, TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, & & EQUED, R, C, B, LDB, X, LDX, RCOND, LFERR, LBERR, & & WORK, IWORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DGESVX1 SUBROUTINE DPOSV1( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB, LDA INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) INTERFACE SUBROUTINE DPOSV( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB, LDA INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) END SUBROUTINE DPOSV END INTERFACE CALL DPOSV( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) END SUBROUTINE DPOSV1 FUNCTION DLANGE1( NORM, M, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => DP REAL(WP) :: DLANGE1 CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: LDA, M, N REAL(WP), INTENT(IN) :: A( * ) REAL(WP), INTENT(OUT) :: WORK( * ) INTERFACE FUNCTION DLANGE( NORM, M, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => DP REAL(WP) :: DLANGE CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: LDA, M, N REAL(WP), INTENT(IN) :: A( LDA, * ) REAL(WP), INTENT(OUT) :: WORK( * ) END FUNCTION DLANGE END INTERFACE DLANGE1 = DLANGE( NORM, M, N, A, LDA, WORK ) END FUNCTION DLANGE1 SUBROUTINE DGBSV1( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: KL, KU, LDAB, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: PIV(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*), B(*) INTERFACE SUBROUTINE DGBSV( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: KL, KU, LDAB, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: PIV(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*), B(LDB,*) END SUBROUTINE DGBSV END INTERFACE CALL DGBSV( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, INFO ) END SUBROUTINE DGBSV1 SUBROUTINE DGBSVX1( FACT, TRANS, N, KL, KU, NRHS, A, LDA, AF, & & LDAF, PIV, EQUED, R, C, B, LDB, X, LDX, RCOND,& & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N, KL, KU INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: PIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: X(*), WORK(*) REAL(WP), INTENT(INOUT) :: R(*), C(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(*) INTERFACE SUBROUTINE DGBSVX( FACT, TRANS, N, KL, KU, NRHS, A, LDA, AF, & & LDAF, PIV, EQUED, R, C, B, LDB, X, LDX, & & RCOND, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N, KL, KU INTEGER, INTENT(OUT) :: INFO ! INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: PIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: R(*), C(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(LDB,*) END SUBROUTINE DGBSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DGBSVX( FACT, TRANS, N, KL, KU, NRHS, A, LDA, AF, LDAF, & & PIV, EQUED, R, C, B, LDB, X, LDX, RCOND, LFERR, & & LBERR, WORK, IWORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DGBSVX1 SUBROUTINE DGTSV1( N, NRHS, DL, D, DU, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: DL(*), D(*), DU(*), B(*) INTERFACE SUBROUTINE DGTSV( N, NRHS, DL, D, DU, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: DL(*), D(*), DU(*), B(LDB,*) END SUBROUTINE DGTSV END INTERFACE CALL DGTSV( N, NRHS, DL, D, DU, B, LDB, INFO ) END SUBROUTINE DGTSV1 SUBROUTINE DGTSVX1( FACT, TRANS, N, NRHS, DL, D, DU, DLF, DF, & & DUF, DU2, IPIV, B, LDB, X, LDX, RCOND, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR, X(*), WORK(*) REAL(WP), INTENT(IN) :: B(*), DL(*), D(*), DU(*) REAL(WP), INTENT(INOUT) :: DF(*), DLF(*), DU2(*), DUF(*) INTERFACE SUBROUTINE DGTSVX( FACT, TRANS, N, NRHS, DL, D, DU, DLF, DF, & & DUF, DU2, IPIV, B, LDB, X, LDX, RCOND, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS, FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*), X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: B(LDB,*), DL(*), D(*), DU(*) REAL(WP), INTENT(INOUT) :: DF(*), DLF(*), DU2(*), DUF(*) END SUBROUTINE DGTSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DGTSVX( FACT, TRANS, N, NRHS, DL, D, DU, DLF, DF, DUF, & & DU2, IPIV, B, LDB, X, LDX, RCOND, LFERR, LBERR, & & WORK, IWORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DGTSVX1 SUBROUTINE DPOSVX1( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, EQUED,& & S, B, LDB, X, LDX, RCOND, FERR, BERR, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: X(*), WORK(*) REAL(WP), INTENT(INOUT) :: S(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(*) INTERFACE SUBROUTINE DPOSVX( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, & & EQUED, S, B, LDB, X, LDX, RCOND, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: S(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), AF(LDAF,*), B(LDB,*) END SUBROUTINE DPOSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DPOSVX( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, EQUED, S, & & B, LDB, X, LDX, RCOND, LFERR, LBERR, WORK, IWORK, & & INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DPOSVX1 SUBROUTINE DPPSV1( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*), B(*) INTERFACE SUBROUTINE DPPSV( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*), B(LDB,*) END SUBROUTINE DPPSV END INTERFACE CALL DPPSV( UPLO, N, NRHS, AP, B, LDB, INFO ) END SUBROUTINE DPPSV1 SUBROUTINE DPPSVX1( FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B, & & LDB, X, LDX, RCOND, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: X(*), WORK(*) REAL(WP), INTENT(INOUT) :: AP(*), AFP(*), B(*), S(*) INTERFACE SUBROUTINE DPPSVX( FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B,& & LDB, X, LDX, RCOND, FERR, BERR, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(INOUT) :: AP(*), AFP(*), B(LDB,*), S(*) END SUBROUTINE DPPSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DPPSVX( FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B, LDB, X,& & LDX, RCOND, LFERR, LBERR, WORK, IWORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DPPSVX1 SUBROUTINE DPBSV1( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB, KD, LDAB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB(LDAB,*), B(*) INTERFACE SUBROUTINE DPBSV( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB, KD, LDAB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB(LDAB,*), B(LDB,*) END SUBROUTINE DPBSV END INTERFACE CALL DPBSV( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) END SUBROUTINE DPBSV1 SUBROUTINE DPBSVX1( FACT, UPLO, N, KD, NRHS, AB, LDAB, AFB, & & LDAFB, EQUED, S, B, LDB, X, LDX, RCOND, FERR,& & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDAB, LDAFB, LDB, LDX, NRHS, N, KD INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: X(*), WORK(*), FERR, BERR, RCOND REAL(WP), INTENT(INOUT) :: AB(LDAB,*), AFB(LDAFB,*), B(*), & & S(*) INTERFACE SUBROUTINE DPBSVX( FACT, UPLO, N, KD, NRHS, AB, LDAB, AFB, & & LDAFB, EQUED, S, B, LDB, X, LDX, RCOND, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT, UPLO CHARACTER(LEN=1), INTENT(INOUT) :: EQUED INTEGER, INTENT(IN) :: LDAB, LDAFB, LDB, LDX, NRHS, N, KD INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*), FERR(*), & & BERR(*), RCOND REAL(WP), INTENT(INOUT) :: AB(LDAB,*), AFB(LDAFB,*), & & B(LDB,*), S(*) END SUBROUTINE DPBSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DPBSVX( FACT, UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, & & EQUED, S, B, LDB, X, LDX, RCOND, LFERR, LBERR, & & WORK, IWORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DPBSVX1 SUBROUTINE DPTSV1( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*) REAL(WP), INTENT(INOUT) :: E(*), B(*) INTERFACE SUBROUTINE DPTSV( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*) REAL(WP), INTENT(INOUT) :: E(*), B(LDB,*) END SUBROUTINE DPTSV END INTERFACE CALL DPTSV( N, NRHS, D, E, B, LDB, INFO ) END SUBROUTINE DPTSV1 SUBROUTINE DPTSVX1( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & RCOND, FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: X(*), WORK(*) REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(IN) :: E(*), B(*) REAL(WP), INTENT(INOUT) :: DF(*) REAL(WP), INTENT(INOUT) :: EF(*) INTERFACE SUBROUTINE DPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, & & LDX, RCOND, FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(IN) :: E(*), B(LDB,*) REAL(WP), INTENT(INOUT) :: DF(*) REAL(WP), INTENT(INOUT) :: EF(*) END SUBROUTINE DPTSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & RCOND, LFERR, LBERR, WORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DPTSVX1 SUBROUTINE DSYSV1( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYSV END INTERFACE CALL DSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, LWORK, & & INFO ) END SUBROUTINE DSYSV1 SUBROUTINE DSYSVX1( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, & & B, LDB, X, LDX, RCOND, FERR, BERR, WORK, & & LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, FACT INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N, LWORK INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: X(*), WORK(*) REAL(WP), INTENT(IN) :: A(LDA,*), B(*) REAL(WP), INTENT(INOUT) :: AF(LDAF,*) INTERFACE SUBROUTINE DSYSVX( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, & & IPIV, B, LDB, X, LDX, RCOND, FERR, BERR, & & WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, FACT INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N, LWORK INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(INOUT) :: AF(LDAF,*) END SUBROUTINE DSYSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DSYSVX( FACT, UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, & & LDB, X, LDX, RCOND, LFERR, LBERR, WORK, LWORK, & & IWORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DSYSVX1 SUBROUTINE DSPSV1( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AP(*), B(*) INTERFACE SUBROUTINE DSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AP(*), B(LDB,*) END SUBROUTINE DSPSV END INTERFACE CALL DSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) END SUBROUTINE DSPSV1 SUBROUTINE DSPSVX1( FACT, UPLO, N, NRHS, A, AF, IPIV, B, LDB, X, & & LDX, RCOND, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: X(*), WORK(*) REAL(WP), INTENT(IN) :: A(*), B(*) REAL(WP), INTENT(INOUT) :: AF(*) INTERFACE SUBROUTINE DSPSVX( FACT, UPLO, N, NRHS, A, AF, IPIV, B, LDB, & & X, LDX, RCOND, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO, FACT INTEGER, INTENT(IN) :: LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IWORK(*) INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(OUT) :: RCOND REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: X(LDX,*), WORK(*) REAL(WP), INTENT(IN) :: A(*), B(LDB,*) REAL(WP), INTENT(INOUT) :: AF(*) END SUBROUTINE DSPSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL DSPSVX( FACT, UPLO, N, NRHS, A, AF, IPIV, B, LDB, X, LDX, & & RCOND, LFERR, LBERR, WORK, IWORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE DSPSVX1 SUBROUTINE DGELS1( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DGELS( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELS END INTERFACE CALL DGELS( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, LWORK, & & INFO ) END SUBROUTINE DGELS1 SUBROUTINE DGELSY1( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: M, N, NRHS, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK INTEGER, INTENT(INOUT) :: JPVT(*) REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: M, N, NRHS, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK INTEGER, INTENT(INOUT) :: JPVT(*) REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELSY END INTERFACE CALL DGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK, & & WORK, LWORK, INFO ) END SUBROUTINE DGELSY1 SUBROUTINE DGELSD1( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(OUT) :: WORK(*) INTEGER :: IWORK(*) INTERFACE SUBROUTINE DGELSD( M, N, NRHS, A, LDA, B, LDB, S, RCOND, & & RANK, WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(OUT) :: WORK(*) INTEGER :: IWORK(*) END SUBROUTINE DGELSD END INTERFACE CALL DGELSD ( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, WORK,& & LWORK, IWORK, INFO ) END SUBROUTINE DGELSD1 SUBROUTINE DGELSX1( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB INTEGER, INTENT(OUT) :: INFO, RANK INTEGER, INTENT(INOUT) :: JPVT(*) REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DGELSX( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB INTEGER, INTENT(OUT) :: INFO, RANK INTEGER, INTENT(INOUT) :: JPVT(*) REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELSX END INTERFACE CALL DGELSX( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK, & & WORK, INFO ) END SUBROUTINE DGELSX1 SUBROUTINE DGELSS1( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DGELSS( M, N, NRHS, A, LDA, B, LDB, S, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: NRHS, M, N, LDA, LDB, LWORK INTEGER, INTENT(OUT) :: INFO, RANK REAL(WP), INTENT(IN) :: RCOND REAL(WP), INTENT(INOUT) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(OUT) :: S(*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGELSS END INTERFACE CALL DGELSS( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, WORK, & & LWORK, INFO ) END SUBROUTINE DGELSS1 SUBROUTINE DGETRS1( TRANS, N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDA, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: PIV(*) REAL(WP), INTENT(IN) :: A(LDA,*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DGETRS( TRANS, N, NRHS, A, LDA, PIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDA, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: PIV(*) REAL(WP), INTENT(IN) :: A(LDA,*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DGETRS END INTERFACE CALL DGETRS( TRANS, N, NRHS, A, LDA, PIV, B, LDB, INFO ) END SUBROUTINE DGETRS1 SUBROUTINE DGERFS1( TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: PIV(*) INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: FERR, BERR REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(IN) :: A(LDA,*), AF(LDAF,*), B(*) REAL(WP), INTENT(INOUT) :: X(*) INTERFACE SUBROUTINE DGERFS( TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, & & B, LDB, X, LDX, FERR, BERR, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: PIV(*) INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: FERR(*), BERR(*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(IN) :: A(LDA,*), AF(LDAF,*), B(LDB,*) REAL(WP), INTENT(INOUT) :: X(LDX,*) END SUBROUTINE DGERFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL DGERFS( TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, B, LDB, & & X, LDX, FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DGERFS1 SUBROUTINE DGBTRS1( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: KL, KU, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AB( LDAB,*), B(*) INTERFACE SUBROUTINE DGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, & & B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: KL, KU, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AB( LDAB,*), B(LDB,*) END SUBROUTINE DGBTRS END INTERFACE CALL DGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB, & & INFO ) END SUBROUTINE DGBTRS1 SUBROUTINE DGBRFS1( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, & & IPIV, B, LDB, X, LDX, FERR, BERR, WORK, IWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: KL, KU, LDAB, LDAFB, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: AB( LDAB,*), AFB( LDAFB,*), B(*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(INOUT) :: X(*) INTERFACE SUBROUTINE DGBRFS( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, & & LDAFB, IPIV, B, LDB, X, LDX, FERR, BERR, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: KL, KU, LDAB, LDAFB, LDB, LDX, N, & & NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) INTEGER, INTENT(OUT) :: IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AB( LDAB,*), AFB( LDAFB,*), & & B( LDB,*) REAL(WP), INTENT(OUT) :: WORK(*) REAL(WP), INTENT(INOUT) :: X( LDX,*) END SUBROUTINE DGBRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL DGBRFS( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, & & IPIV, B, LDB, X, LDX, FERR1, BERR1, WORK, IWORK, & & INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DGBRFS1 SUBROUTINE DGTTRS1( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IPIV(*) REAL(WP), INTENT(IN) :: D(*), DL(*), DU(*), DU2(*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DGTTRS( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: IPIV(*) REAL(WP), INTENT(IN) :: D(*), DL(*), DU(*), DU2(*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DGTTRS END INTERFACE CALL DGTTRS( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, LDB, & & INFO ) END SUBROUTINE DGTTRS1 SUBROUTINE DGTRFS1( TRANS, N, NRHS, DL, D, DU, DLF, DF, DUF, DU2, & & IPIV, B, LDB, X, LDX, FERR, BERR, WORK, IWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS, IPIV(*) INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: B(*), D(*), DF(*), DL(*), DLF(*), & & DU(*), DU2(*), DUF(*) REAL(WP), INTENT(INOUT) :: X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DGTRFS( TRANS, N, NRHS, DL, D, DU, DLF, DF, DUF, & & DU2, IPIV, B, LDB, X, LDX, FERR, BERR, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: TRANS INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS, IPIV(*) INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: B( LDB,*), D(*), DF(*), DL(*), & & DLF(*), DU(*), DU2(*), DUF(*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DGTRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL DGTRFS( TRANS, N, NRHS, DL, D, DU, DLF, DF, DUF, DU2, & & IPIV, B, LDB, X, LDX, FERR1, BERR1, WORK, IWORK, & & INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DGTRFS1 SUBROUTINE DPOTRS1( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A( LDA,*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DPOTRS( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A( LDA,*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DPOTRS END INTERFACE CALL DPOTRS( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) END SUBROUTINE DPOTRS1 SUBROUTINE DPORFS1( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: A(*), AF( LDAF,*), B( LDB,*) REAL(WP), INTENT(INOUT) :: X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DPORFS( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, & & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: A( LDA,*), AF( LDAF,*), & & B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPORFS END INTERFACE REAL(WP) :: BERR1(1), FERR1(1) CALL DPORFS( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, X, LDX, & & FERR1, BERR1, WORK, IWORK, INFO ) BERR = BERR1(1); FERR = FERR1(1) END SUBROUTINE DPORFS1 SUBROUTINE DPPTRS1( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DPPTRS( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DPPTRS END INTERFACE CALL DPPTRS( UPLO, N, NRHS, AP, B, LDB, INFO ) END SUBROUTINE DPPTRS1 SUBROUTINE DPPRFS1( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: AFP(*), AP(*), B(*) REAL(WP), INTENT(INOUT) :: X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DPPRFS( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AFP(*), AP(*), B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPPRFS END INTERFACE REAL(WP) :: BERR1(1), FERR1(1) CALL DPPRFS( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR1, & & BERR1, WORK, IWORK, INFO ) BERR = BERR1(1); FERR = FERR1(1) END SUBROUTINE DPPRFS1 SUBROUTINE DPBTRS1( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AB( LDAB,*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DPBTRS( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AB( LDAB,*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DPBTRS END INTERFACE CALL DPBTRS( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) END SUBROUTINE DPBTRS1 SUBROUTINE DPBRFS1( UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDAFB, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: AB( LDAB,*), AFB( LDAFB,*), B(*) REAL(WP), INTENT(INOUT) :: X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DPBRFS( UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, & & B, LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDAFB, LDB, LDX, N, & & NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AB( LDAB,*), AFB( LDAFB,*), & & B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPBRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL DPBRFS( UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, B, LDB, & & X, LDX, FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DPBRFS1 SUBROUTINE DPTTRS1( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(IN) :: E(*) REAL(WP), INTENT(OUT) :: B(*) INTERFACE SUBROUTINE DPTTRS( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: D(*) REAL(WP), INTENT(IN) :: E(*) REAL(WP), INTENT(OUT) :: B( LDB,*) END SUBROUTINE DPTTRS END INTERFACE CALL DPTTRS( N, NRHS, D, E, B, LDB, INFO ) END SUBROUTINE DPTTRS1 SUBROUTINE DPTRFS1( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR, & & BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: D(*), DF(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: B(*), E(*), EF(*) REAL(WP), INTENT(INOUT) :: X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DPTRFS( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => DP INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: D(*), DF(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: B( LDB,*), E(*), EF(*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DPTRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL DPTRFS( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR1, & & BERR1, WORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DPTRFS1 SUBROUTINE DSYTRS1( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER , INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: A( LDA,*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER , INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: A( LDA,*) REAL(WP), INTENT(INOUT) :: B( LDB,*) END SUBROUTINE DSYTRS END INTERFACE CALL DSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO ) END SUBROUTINE DSYTRS1 SUBROUTINE DSYRFS1( UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB,& & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: A( LDA,*), AF( LDAF,*), B(*) REAL(WP), INTENT(INOUT) :: X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DSYRFS( UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B,& & LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, LDAF, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: A( LDA,*), AF( LDAF,*), & & B( LDB,*) REAL(WP), INTENT(INOUT) :: X( LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSYRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL DSYRFS( UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, X, & & LDX, FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DSYRFS1 SUBROUTINE DSPTRS1( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DSPTRS ENDINTERFACE CALL DSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) END SUBROUTINE DSPTRS1 SUBROUTINE DSPRFS1( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: AFP(*), AP(*), B(LDB,*) REAL(WP), INTENT(INOUT) :: X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DSPRFS( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) INTEGER, INTENT(IN) :: IPIV(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AFP(*), AP(*), B(LDB,*) REAL(WP), INTENT(INOUT) :: X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DSPRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL DSPRFS( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, & & FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DSPRFS1 SUBROUTINE DTRTRS1( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DTRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDA, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: A(LDA,*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DTRTRS END INTERFACE CALL DTRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, & & INFO ) END SUBROUTINE DTRTRS1 SUBROUTINE DTRRFS1( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X,& & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDA, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: A(LDA,*), B(*) REAL(WP), INTENT(INOUT) :: X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DTRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDA, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: A(LDA,*), B(LDB,*) REAL(WP), INTENT(INOUT) :: X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTRRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL DTRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, & & LDX, FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DTRRFS1 SUBROUTINE DTPTRS1( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DTPTRS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AP(*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DTPTRS END INTERFACE CALL DTPTRS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, INFO ) END SUBROUTINE DTPTRS1 SUBROUTINE DTPRFS1( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: AP(*), B(*), X(*) REAL(WP), INTENT(OUT) :: WORK(*) INTERFACE SUBROUTINE DTPRFS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, & & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AP(*), B(LDB,*), X(LDX,*) REAL(WP), INTENT(OUT) :: WORK(*) END SUBROUTINE DTPRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL DTPRFS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, & & FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DTPRFS1 SUBROUTINE DTBTRS1( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AB(LDAB,*) REAL(WP), INTENT(INOUT) :: B(*) INTERFACE SUBROUTINE DTBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB,& & B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, N, NRHS INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(IN) :: AB(LDAB,*) REAL(WP), INTENT(INOUT) :: B(LDB,*) END SUBROUTINE DTBTRS END INTERFACE CALL DTBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, & & INFO ) END SUBROUTINE DTBTRS1 SUBROUTINE DTBRFS1( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR, FERR REAL(WP), INTENT(IN) :: AB(LDAB,*), B(*), X(*) REAL(WP), INTENT(IN) :: WORK(*) INTERFACE SUBROUTINE DTBRFS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB,& & B, LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => DP CHARACTER(LEN=1), INTENT(IN) :: DIAG, TRANS, UPLO INTEGER, INTENT(IN) :: KD, LDAB, LDB, LDX, N, NRHS INTEGER, INTENT(OUT) :: INFO, IWORK(*) REAL(WP), INTENT(OUT) :: BERR(*), FERR(*) REAL(WP), INTENT(IN) :: AB(LDAB,*), B(LDB,*), X(LDX,*) REAL(WP), INTENT(IN) :: WORK(*) END SUBROUTINE DTBRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL DTBRFS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, & & X, LDX, FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE DTBRFS1 END MODULE F77_LAPACK