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 SLANGB( NORM, N, KL, KU, AB, LDAB, WORK ) USE LA_PRECISION, ONLY: WP => SP REAL(WP) :: SLANGB 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 SLANGB END INTERFACE INTERFACE LA_TGSEN SUBROUTINE STGSEN( 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 => SP 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 STGSEN END INTERFACE INTERFACE LA_TGSNA SUBROUTINE STGSNA( 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 => SP 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 STGSNA END INTERFACE INTERFACE LA_TGSYL SUBROUTINE STGSYL( 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 => SP 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 STGSYL END INTERFACE INTERFACE LA_TGEXC SUBROUTINE STGEXC( WANTQ, WANTZ, N, A, LDA, B, LDB, Q, LDQ, Z, & & LDZ, IFST, ILST, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STGEXC END INTERFACE INTERFACE LA_BDSDC SUBROUTINE SBDSDC( UPLO, COMPQ, N, D, E, U, LDU, VT, LDVT, Q, & & IQ, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SBDSDC END INTERFACE INTERFACE LA_STEGR SUBROUTINE SSTEGR( 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 => SP 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 SSTEGR END INTERFACE INTERFACE LA_ORMRZ SUBROUTINE SORMRZ( SIDE, TRANS, M, N, K, L, A, LDA, TAU, C, & & LDC, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMRZ END INTERFACE INTERFACE LA_TZRZF SUBROUTINE STZRZF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STZRZF END INTERFACE INTERFACE LA_GEQP3 SUBROUTINE SGEQP3( M, N, A, LDA, JPVT, TAU, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEQP3 END INTERFACE INTERFACE LA_GESDD SUBROUTINE SGESDD( JOBZ, M, N, A, LDA, S, U, LDU, VT, LDVT, & & WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGESDD END INTERFACE INTERFACE LA_GGRQF SUBROUTINE SGGRQF( M, P, N, A, LDA, TAUA, B, LDB, TAUB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGRQF END INTERFACE INTERFACE LA_GGQRF SUBROUTINE SGGQRF( N, M, P, A, LDA, TAUA, B, LDB, TAUB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGQRF END INTERFACE INTERFACE LA_DISNA SUBROUTINE SDISNA( JOB, M, N, D, SEP, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SDISNA END INTERFACE INTERFACE LA_TGSJA SUBROUTINE STGSJA( 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 => SP 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 STGSJA END INTERFACE INTERFACE LA_GGSVP SUBROUTINE SGGSVP( 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 => SP 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 SGGSVP END INTERFACE INTERFACE LA_TGEVC SUBROUTINE STGEVC( SIDE, HOWMNY, SELECT, N, A, LDA, B, LDB, VL, & & LDVL, VR, LDVR, MM, M, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STGEVC END INTERFACE INTERFACE LA_HGEQZ SUBROUTINE SHGEQZ( 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 => SP 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 SHGEQZ END INTERFACE INTERFACE LA_GGBAK SUBROUTINE SGGBAK( JOB, SIDE, N, ILO, IHI, LSCALE, RSCALE, M, V, & & LDV, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGBAK END INTERFACE INTERFACE LA_GGBAL SUBROUTINE SGGBAL( JOB, N, A, LDA, B, LDB, ILO, IHI, LSCALE, & & RSCALE, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGBAL END INTERFACE INTERFACE LA_GGHRD SUBROUTINE SGGHRD( COMPQ, COMPZ, N, ILO, IHI, A, LDA, B, LDB, Q, & & LDQ, Z, LDZ, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGHRD END INTERFACE INTERFACE LA_PBSTF SUBROUTINE SPBSTF( UPLO, N, KD, AB, LDAB, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) ::UPLO INTEGER, INTENT(IN) :: KD, LDAB, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB( LDAB, * ) END SUBROUTINE SPBSTF END INTERFACE INTERFACE LA_SBGST SUBROUTINE SSBGST( VECT, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, X, & & LDX, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSBGST END INTERFACE INTERFACE LA_SPGST SUBROUTINE SSPGST( ITYPE, UPLO, N, AP, BP, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPGST END INTERFACE INTERFACE LA_BDSQR SUBROUTINE SBDSQR( UPLO, N, NCVT, NRU, NCC, D, E, VT, LDVT, U, & & LDU, C, LDC, RWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SBDSQR END INTERFACE INTERFACE LA_ORMBR SUBROUTINE SORMBR( VECT, SIDE, TRANS, M, N, K, A, LDA, TAU, C, & & LDC, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMBR END INTERFACE INTERFACE LA_ORGBR SUBROUTINE SORGBR( VECT, M, N, K, A, LDA, TAU, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORGBR END INTERFACE INTERFACE LA_GBBRD SUBROUTINE SGBBRD( VECT, M, N, NCC, KL, KU, AB, LDAB, D, E, Q, & & LDQ, PT, LDPT, C, LDC, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBBRD END INTERFACE INTERFACE LA_GEBRD SUBROUTINE SGEBRD( M, N, A, LDA, D, E, TAUQ, TAUP, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEBRD END INTERFACE INTERFACE LA_TRSEN SUBROUTINE STRSEN( JOB, COMPQ, SELECT, N, T, LDT, Q, LDQ, WR, WI, & & M, S, SEP, WORK, LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRSEN END INTERFACE INTERFACE LA_TRSNA SUBROUTINE STRSNA( JOB, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR, & & LDVR, S, SEP, MM, M, WORK, LDWORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRSNA END INTERFACE INTERFACE LA_TRSYL SUBROUTINE STRSYL( TRANA, TRANB, ISGN, M, N, A, LDA, B, LDB, C, & & LDC, SCALE, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRSYL END INTERFACE INTERFACE LA_TREXC SUBROUTINE STREXC( COMPQ, N, T, LDT, Q, LDQ, IFST, ILST, WORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STREXC END INTERFACE INTERFACE LA_TREVC SUBROUTINE STREVC( SIDE, HOWMNY, SELECT, N, T, LDT, VL, LDVL, VR, & & LDVR, MM, M, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STREVC END INTERFACE INTERFACE LA_HSEIN SUBROUTINE SHSEIN( SIDE, EIGSRC, INITV, SELECT, N, H, LDH, WR, WI,& & VL, LDVL, VR, LDVR, MM, M, WORK, IFAILL, & & IFAILR, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SHSEIN END INTERFACE INTERFACE LA_HSEQR SUBROUTINE SHSEQR( JOB, COMPZ, N, ILO, IHI, H, LDH, WR, WI, Z, & & LDZ, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SHSEQR END INTERFACE INTERFACE LA_ORMHR SUBROUTINE SORMHR( SIDE, TRANS, M, N, ILO, IHI, A, LDA, TAU, C, & & LDC, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMHR END INTERFACE INTERFACE LA_ORGHR SUBROUTINE SORGHR( N, ILO, IHI, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORGHR END INTERFACE INTERFACE LA_GEBAK SUBROUTINE SGEBAK( JOB, SIDE, N, ILO, IHI, SCALE, M, V, LDV, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEBAK END INTERFACE INTERFACE LA_GEBAL SUBROUTINE SGEBAL( JOB, N, A, LDA, ILO, IHI, SCALE, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEBAL END INTERFACE INTERFACE LA_GEHRD SUBROUTINE SGEHRD( N, ILO, IHI, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEHRD END INTERFACE INTERFACE LA_PTEQR SUBROUTINE SPTEQR( COMPZ, N, D, E, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTEQR END INTERFACE INTERFACE LA_STEIN SUBROUTINE SSTEIN( N, D, E, M, W, IBLOCK, ISPLIT, Z, LDZ, WORK, & & IWORK, IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSTEIN END INTERFACE INTERFACE LA_STEBZ SUBROUTINE SSTEBZ( RANGE, ORDER, N, VL, VU, IL, IU, ABSTOL, D, E, & & M, NSPLIT, W, IBLOCK, ISPLIT, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSTEBZ END INTERFACE INTERFACE LA_STEDC SUBROUTINE SSTEDC( COMPZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, & & LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSTEDC END INTERFACE INTERFACE LA_STERF SUBROUTINE SSTERF( N, D, E, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*), E(*) END SUBROUTINE SSTERF END INTERFACE INTERFACE LA_STEQR SUBROUTINE SSTEQR( COMPZ, N, D, E, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSTEQR END INTERFACE INTERFACE LA_OPMTR SUBROUTINE SOPMTR( SIDE, UPLO, TRANS, M, N, AP, TAU, C, LDC, WORK,& & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SOPMTR END INTERFACE INTERFACE LA_OPGTR SUBROUTINE SOPGTR( UPLO, N, AP, TAU, Q, LDQ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SOPGTR END INTERFACE INTERFACE LA_ORMTR SUBROUTINE SORMTR( SIDE, UPLO, TRANS, M, N, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMTR END INTERFACE INTERFACE LA_SBTRD SUBROUTINE SSBTRD( VECT, UPLO, N, KD, AB, LDAB, D, E, Q, LDQ, & & WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSBTRD END INTERFACE INTERFACE LA_SPTRD SUBROUTINE SSPTRD( UPLO, N, AP, D, E, TAU, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPTRD END INTERFACE INTERFACE LA_TZRQF SUBROUTINE STZRQF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STZRQF END INTERFACE INTERFACE LA_ORMRQ SUBROUTINE SORMRQ( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMRQ END INTERFACE INTERFACE LA_ORGRQ SUBROUTINE SORGRQ( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORGRQ END INTERFACE INTERFACE LA_GERQF SUBROUTINE SGERQF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGERQF END INTERFACE INTERFACE LA_ORMQL SUBROUTINE SORMQL( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMQL END INTERFACE INTERFACE LA_ORGQL SUBROUTINE SORGQL( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORGQL END INTERFACE INTERFACE LA_GEQLF SUBROUTINE SGEQLF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEQLF END INTERFACE INTERFACE LA_ORMLQ SUBROUTINE SORMLQ( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMLQ END INTERFACE INTERFACE LA_ORGLQ SUBROUTINE SORGLQ( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORGLQ END INTERFACE INTERFACE LA_GELQF SUBROUTINE SGELQF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELQF END INTERFACE INTERFACE LA_ORMQR SUBROUTINE SORMQR( SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORMQR END INTERFACE INTERFACE LA_ORGQR SUBROUTINE SORGQR( M, N, K, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORGQR END INTERFACE INTERFACE LA_GEQRF SUBROUTINE SGEQRF( M, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEQRF END INTERFACE INTERFACE LA_GEQPF SUBROUTINE SGEQPF( M, N, A, LDA, JPVT, TAU, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEQPF END INTERFACE INTERFACE LA_TBRFS SUBROUTINE STBRFS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STBRFS MODULE PROCEDURE STBRFS1 END INTERFACE INTERFACE LA_TBCON SUBROUTINE STBCON( NORM, UPLO, DIAG, N, KD, AB, LDAB, RCOND, WORK,& & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STBCON END INTERFACE INTERFACE LA_TBTRS SUBROUTINE STBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STBTRS MODULE PROCEDURE STBTRS1 END INTERFACE INTERFACE LA_TPTRI SUBROUTINE STPTRI( UPLO, DIAG, N, AP, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: DIAG, UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP( * ) END SUBROUTINE STPTRI END INTERFACE INTERFACE LA_TPRFS SUBROUTINE STPRFS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX,& & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STPRFS MODULE PROCEDURE STPRFS1 END INTERFACE INTERFACE LA_TPCON SUBROUTINE STPCON( NORM, UPLO, DIAG, N, AP, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STPCON END INTERFACE INTERFACE LA_TPTRS SUBROUTINE STPTRS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STPTRS MODULE PROCEDURE STPTRS1 END INTERFACE INTERFACE LA_TRTRI SUBROUTINE STRTRI( UPLO, DIAG, N, A, LDA, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: DIAG, UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A( LDA, * ) END SUBROUTINE STRTRI END INTERFACE INTERFACE LA_TRRFS SUBROUTINE STRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRRFS MODULE PROCEDURE STRRFS1 END INTERFACE INTERFACE LA_TRCON SUBROUTINE STRCON( NORM, UPLO, DIAG, N, A, LDA, RCOND, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRCON END INTERFACE INTERFACE LA_TRTRS SUBROUTINE STRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRTRS MODULE PROCEDURE STRTRS1 END INTERFACE INTERFACE LA_SPTRI SUBROUTINE SSPTRI( UPLO, N, AP, IPIV, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPTRI END INTERFACE INTERFACE LA_SPRFS SUBROUTINE SSPRFS( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPRFS MODULE PROCEDURE SSPRFS1 END INTERFACE INTERFACE LA_SPCON SUBROUTINE SSPCON( UPLO, N, AP, IPIV, ANORM, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPCON END INTERFACE INTERFACE LA_SPTRS SUBROUTINE SSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPTRS MODULE PROCEDURE SSPTRS1 END INTERFACE INTERFACE LA_SPTRF SUBROUTINE SSPTRF( UPLO, N, AP, IPIV, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO, IPIV(*) REAL(WP), INTENT(INOUT) :: AP(*) END SUBROUTINE SSPTRF END INTERFACE INTERFACE LA_SYTRI SUBROUTINE SSYTRI( UPLO, N, A, LDA, IPIV, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYTRI END INTERFACE INTERFACE LA_SYRFS SUBROUTINE SSYRFS( UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB, & & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYRFS MODULE PROCEDURE SSYRFS1 END INTERFACE INTERFACE LA_SYCON SUBROUTINE SSYCON( UPLO, N, A, LDA, IPIV, ANORM, RCOND, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYCON END INTERFACE INTERFACE LA_SYTRS SUBROUTINE SSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYTRS MODULE PROCEDURE SSYTRS1 END INTERFACE INTERFACE LA_SYTRF SUBROUTINE SSYTRF( UPLO, N, A, LDA, IPIV, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYTRF END INTERFACE INTERFACE LA_PTRFS SUBROUTINE SPTRFS( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR, & & BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTRFS MODULE PROCEDURE SPTRFS1 END INTERFACE INTERFACE LA_PTCON SUBROUTINE SPTCON( N, D, E, ANORM, RCOND, RWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTCON END INTERFACE INTERFACE LA_PTTRS SUBROUTINE SPTTRS( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTTRS MODULE PROCEDURE SPTTRS1 END INTERFACE INTERFACE LA_PTTRF SUBROUTINE SPTTRF( N, D, E, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D( * ) REAL(WP), INTENT(INOUT) :: E( * ) END SUBROUTINE SPTTRF END INTERFACE INTERFACE LA_PBEQU SUBROUTINE SPBEQU( UPLO, N, KD, AB, LDAB, S, SCOND, AMAX, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBEQU END INTERFACE INTERFACE LA_PBRFS SUBROUTINE SPBRFS( UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBRFS MODULE PROCEDURE SPBRFS1 END INTERFACE INTERFACE LA_PBCON SUBROUTINE SPBCON( UPLO, N, KD, AB, LDAB, ANORM, RCOND, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBCON END INTERFACE INTERFACE LA_PBTRS SUBROUTINE SPBTRS( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBTRS MODULE PROCEDURE SPBTRS1 END INTERFACE INTERFACE LA_PBTRF SUBROUTINE SPBTRF( UPLO, N, KD, AB, LDAB, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: KD, LDAB, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AB( LDAB,*) END SUBROUTINE SPBTRF END INTERFACE INTERFACE LA_PPEQU SUBROUTINE SPPEQU( UPLO, N, AP, S, SCOND, AMAX, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPEQU END INTERFACE INTERFACE LA_PPTRI SUBROUTINE SPPTRI( UPLO, N, AP, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*) END SUBROUTINE SPPTRI END INTERFACE INTERFACE LA_PPRFS SUBROUTINE SPPRFS( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPRFS MODULE PROCEDURE SPPRFS1 END INTERFACE INTERFACE LA_PPCON SUBROUTINE SPPCON( UPLO, N, AP, ANORM, RCOND, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPCON END INTERFACE INTERFACE LA_PPTRS SUBROUTINE SPPTRS( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPTRS MODULE PROCEDURE SPPTRS1 END INTERFACE INTERFACE LA_PPTRF SUBROUTINE SPPTRF( UPLO, N, AP, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*) END SUBROUTINE SPPTRF END INTERFACE INTERFACE LA_POEQU SUBROUTINE SPOEQU( N, A, LDA, S, SCOND, AMAX, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(OUT) :: AMAX, SCOND, S(*) REAL(WP), INTENT(IN) :: A( LDA,*) END SUBROUTINE SPOEQU END INTERFACE INTERFACE LA_POTRI SUBROUTINE SPOTRI( UPLO, N, A, LDA, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A( LDA,*) END SUBROUTINE SPOTRI END INTERFACE INTERFACE LA_PORFS SUBROUTINE SPORFS( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPORFS MODULE PROCEDURE SPORFS1 END INTERFACE INTERFACE LA_POTRS SUBROUTINE SPOTRS( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPOTRS MODULE PROCEDURE SPOTRS1 END INTERFACE INTERFACE LA_GTRFS SUBROUTINE SGTRFS( 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 => SP 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 SGTRFS MODULE PROCEDURE SGTRFS1 END INTERFACE INTERFACE LA_GTCON SUBROUTINE SGTCON( NORM, N, DL, D, DU, DU2, IPIV, ANORM, RCOND, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGTCON END INTERFACE INTERFACE LA_GTTRS SUBROUTINE SGTTRS( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGTTRS MODULE PROCEDURE SGTTRS1 END INTERFACE INTERFACE LA_GTTRF SUBROUTINE SGTTRF( N, DL, D, DU, DU2, IPIV, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGTTRF END INTERFACE INTERFACE LA_GBEQU SUBROUTINE SGBEQU( M, N, KL, KU, AB, LDAB, R, C, ROWCND, COLCND, & & AMAX, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBEQU END INTERFACE INTERFACE LA_GBRFS SUBROUTINE SGBRFS( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, & & IPIV, B, LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBRFS MODULE PROCEDURE SGBRFS1 END INTERFACE INTERFACE LA_GBCON SUBROUTINE SGBCON( NORM, N, KL, KU, AB, LDAB, IPIV, ANORM, RCOND, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBCON END INTERFACE INTERFACE LA_GBTRS SUBROUTINE SGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB,& & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBTRS MODULE PROCEDURE SGBTRS1 END INTERFACE INTERFACE LA_GBTRF SUBROUTINE SGBTRF( M, N, KL, KU, AB, LDAB, IPIV, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: KL, KU, LDAB, M, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(INOUT) :: IPIV(*) REAL(WP), INTENT(INOUT) :: AB(LDAB,*) END SUBROUTINE SGBTRF END INTERFACE INTERFACE FUNCTION SLAMCH( CMACH ) USE LA_PRECISION, ONLY: WP => SP REAL(WP) :: SLAMCH CHARACTER(LEN=1), INTENT(IN) :: CMACH END FUNCTION SLAMCH END INTERFACE INTERFACE LA_GGSVD SUBROUTINE SGGSVD( 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 => SP 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 SGGSVD END INTERFACE INTERFACE LA_GEGV SUBROUTINE SGEGV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, & & ALPHAI, BETA, VL, LDVL, VR, LDVR, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEGV END INTERFACE INTERFACE LA_GEGS SUBROUTINE SGEGS( JOBVSL, JOBVSR, N, A, LDA, B, LDB, ALPHAR, & & ALPHAI, BETA, VSL, LDVSL, VSR, LDVSR, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEGS END INTERFACE INTERFACE LA_SBGVX SUBROUTINE SSBGVX( 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 => SP 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 SSBGVX END INTERFACE INTERFACE LA_SBGVD SUBROUTINE SSBGVD( JOBZ, UPLO, N, KAB, KBB, AB, LDAB, BB, LDBB, & & W, Z, LDZ, WORK, LWORK, IWORK, LIWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSBGVD END INTERFACE INTERFACE LA_SBGV SUBROUTINE SSBGV( JOBZ, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, W, & & Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSBGV END INTERFACE INTERFACE LA_SPGVX SUBROUTINE SSPGVX( 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 => SP 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 SSPGVX END INTERFACE INTERFACE LA_SPGVD SUBROUTINE SSPGVD( ITYPE, JOBZ, UPLO, N, AP, BP, W, Z, LDZ, & & WORK, LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPGVD END INTERFACE INTERFACE LA_SPGV SUBROUTINE SSPGV( ITYPE, JOBZ, UPLO, N, AP, BP, W, Z, LDZ, WORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPGV END INTERFACE INTERFACE LA_GESVD SUBROUTINE SGESVD( JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT, & & LDVT, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGESVD END INTERFACE INTERFACE LA_GEEVX SUBROUTINE SGEEVX( 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 => SP 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 SGEEVX END INTERFACE INTERFACE LA_GGEVX SUBROUTINE SGGEVX( 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 => SP 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 SGGEVX END INTERFACE INTERFACE LA_GGEV SUBROUTINE SGGEV( JOBVL, JOBVR, N, A, LDA, B, LDB, ALPHAR, & & ALPHAI, BETA, VL, LDVL, VR, LDVR, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGEV END INTERFACE INTERFACE LA_GEEV SUBROUTINE SGEEV( JOBVL, JOBVR, N, A, LDA, WR, WI, VL, LDVL, VR, & & LDVR, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEEV END INTERFACE INTERFACE LA_GEESX SUBROUTINE SGEESX( 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 => SP INTERFACE LOGICAL FUNCTION SELECT(WR, WI) USE LA_PRECISION, ONLY: WP => SP 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 SGEESX END INTERFACE INTERFACE LA_GGESX SUBROUTINE SGGESX( JOBVSL, JOBVSR, SORT, SELCTG, 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 => SP 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 SELCTG(ALPHAR, ALPHAI, BETA) USE LA_PRECISION, ONLY: WP => SP REAL(WP), INTENT(IN) :: ALPHAR, ALPHAI, BETA END FUNCTION SELCTG END INTERFACE OPTIONAL :: SELCTG END SUBROUTINE SGGESX END INTERFACE INTERFACE LA_GGES SUBROUTINE SGGES( JOBVSL, JOBVSR, SORT, SELCTG, N, A, LDA, B, & & LDB, SDIM, ALPHAR, ALPHAI, BETA, VSL, LDVSL, & & VSR, LDVSR, WORK, LWORK, BWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SELCTG(ALPHAR, ALPHAI, BETA) USE LA_PRECISION, ONLY: WP => SP REAL(WP), INTENT(IN) :: ALPHAR, ALPHAI, BETA END FUNCTION SELCTG END INTERFACE OPTIONAL :: SELCTG END SUBROUTINE SGGES END INTERFACE INTERFACE LA_GEES SUBROUTINE SGEES( JOBVS, SORT, SELECT, N, A, LDA, SDIM, WR, WI, & & VS, LDVS, WORK, LWORK, BWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP INTERFACE LOGICAL FUNCTION SELECT(WR, WI) USE LA_PRECISION, ONLY: WP => SP 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 SGEES END INTERFACE INTERFACE LA_STEVR SUBROUTINE SSTEVR( 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 => SP 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 SSTEVR END INTERFACE INTERFACE LA_STEVX SUBROUTINE SSTEVX( JOBZ, RANGE, N, D, E, VL, VU, IL, IU, ABSTOL, & & M, W, Z, LDZ, WORK, IWORK, IFAIL, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSTEVX END INTERFACE INTERFACE LA_STEVD SUBROUTINE SSTEVD( JOBZ, N, D, E, Z, LDZ, WORK, LWORK, IWORK, & & LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSTEVD END INTERFACE INTERFACE LA_STEV SUBROUTINE SSTEV( JOBZ, N, D, E, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSTEV END INTERFACE INTERFACE LA_SBEVX SUBROUTINE SSBEVX( 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 => SP 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 SSBEVX END INTERFACE INTERFACE LA_SBEVD SUBROUTINE SSBEVD( JOBZ, UPLO, N, KD, AB, LDAB, W, Z, LDZ, WORK, & & LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSBEVD END INTERFACE INTERFACE LA_SBEV SUBROUTINE SSBEV( JOBZ, UPLO, N, KD, AB, LDAB, W, Z, LDZ, WORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSBEV END INTERFACE INTERFACE LA_SPEVX SUBROUTINE SSPEVX( JOBZ, RANGE, UPLO, N, AP, VL, VU, IL, IU, & & ABSTOL, M, W, Z, LDZ, WORK, IWORK, IFAIL, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPEVX END INTERFACE INTERFACE LA_SPEVD SUBROUTINE SSPEVD( JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, LWORK, & & IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPEVD END INTERFACE INTERFACE LA_SPEV SUBROUTINE SSPEV( JOBZ, UPLO, N, AP, W, Z, LDZ, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPEV END INTERFACE INTERFACE LA_GGGLM SUBROUTINE SGGGLM( N, M, P, A, LDA, B, LDB, D, X, Y, WORK, LWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGGLM END INTERFACE INTERFACE LA_GGLSE SUBROUTINE SGGLSE( M, N, P, A, LDA, B, LDB, C, D, X, WORK, LWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGGLSE END INTERFACE INTERFACE LA_GELSY SUBROUTINE SGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSY MODULE PROCEDURE SGELSY1 END INTERFACE INTERFACE LA_GELSD SUBROUTINE SGELSD( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSD MODULE PROCEDURE SGELSD1 END INTERFACE INTERFACE LA_GELSX SUBROUTINE SGELSX( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK,& & WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSX MODULE PROCEDURE SGELSX1 END INTERFACE INTERFACE LA_GELSS SUBROUTINE SGELSS( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSS MODULE PROCEDURE SGELSS1 END INTERFACE INTERFACE LA_GELS SUBROUTINE SGELS( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, LWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELS MODULE PROCEDURE SGELS1 END INTERFACE INTERFACE LA_SPSV SUBROUTINE SSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPSV MODULE PROCEDURE SSPSV1 END INTERFACE INTERFACE LA_SYSV SUBROUTINE SSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYSV MODULE PROCEDURE SSYSV1 END INTERFACE INTERFACE LA_PTSV SUBROUTINE SPTSV( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*) REAL(WP), INTENT(INOUT) :: E(*), B(LDB,*) END SUBROUTINE SPTSV MODULE PROCEDURE SPTSV1 END INTERFACE INTERFACE LA_PBSV SUBROUTINE SPBSV( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBSV MODULE PROCEDURE SPBSV1 END INTERFACE INTERFACE LA_PPSV SUBROUTINE SPPSV( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPSV MODULE PROCEDURE SPPSV1 END INTERFACE INTERFACE LA_POSV SUBROUTINE SPOSV( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPOSV MODULE PROCEDURE SPOSV1 END INTERFACE INTERFACE LA_GTSV SUBROUTINE SGTSV( N, NRHS, DL, D, DU, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: DL(*), D(*), DU(*), B(LDB,*) END SUBROUTINE SGTSV MODULE PROCEDURE SGTSV1 END INTERFACE INTERFACE LA_GBSV SUBROUTINE SGBSV( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBSV MODULE PROCEDURE SGBSV1 END INTERFACE INTERFACE LA_GESV SUBROUTINE SGESV( N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGESV MODULE PROCEDURE SGESV1 END INTERFACE INTERFACE LA_SPSVX SUBROUTINE SSPSVX( FACT, UPLO, N, NRHS, A, AF, IPIV, B, LDB, X, & & LDX, RCOND, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPSVX MODULE PROCEDURE SSPSVX1 END INTERFACE INTERFACE LA_SYSVX SUBROUTINE SSYSVX( 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 => SP 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 SSYSVX MODULE PROCEDURE SSYSVX1 END INTERFACE INTERFACE LA_PTSVX SUBROUTINE SPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & RCOND, FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTSVX MODULE PROCEDURE SPTSVX1 END INTERFACE INTERFACE LA_PBSVX SUBROUTINE SPBSVX( 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 => SP 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 SPBSVX MODULE PROCEDURE SPBSVX1 END INTERFACE INTERFACE LA_PPSVX SUBROUTINE SPPSVX( FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B, & & LDB, X, LDX, RCOND, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPSVX MODULE PROCEDURE SPPSVX1 END INTERFACE INTERFACE LA_POSVX SUBROUTINE SPOSVX( 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 => SP 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 SPOSVX MODULE PROCEDURE SPOSVX1 END INTERFACE INTERFACE LA_GTSVX SUBROUTINE SGTSVX( 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 => SP 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 SGTSVX MODULE PROCEDURE SGTSVX1 END INTERFACE INTERFACE LA_GBSVX SUBROUTINE SGBSVX( 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 => SP 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 SGBSVX MODULE PROCEDURE SGBSVX1 END INTERFACE INTERFACE LA_GESVX SUBROUTINE SGESVX( 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 => SP 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 SGESVX MODULE PROCEDURE SGESVX1 END INTERFACE INTERFACE LA_GETRF SUBROUTINE SGETRF( M, N, A, LDA, PIV, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: LDA, M, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT( OUT ) :: PIV( * ) REAL(WP), INTENT( INOUT ) :: A( LDA, * ) END SUBROUTINE SGETRF END INTERFACE INTERFACE LA_GETRS SUBROUTINE SGETRS( TRANS, N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGETRS MODULE PROCEDURE SGETRS1 END INTERFACE INTERFACE LA_GETRI SUBROUTINE SGETRI( N, A, LDA, IPIV, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGETRI END INTERFACE INTERFACE LA_GERFS SUBROUTINE SGERFS( TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, B, LDB,& & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGERFS MODULE PROCEDURE SGERFS1 END INTERFACE INTERFACE LA_GEEQU SUBROUTINE SGEEQU( M, N, A, LDA, R, C, ROWCND, COLCND, AMAX, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGEEQU END INTERFACE INTERFACE LA_LANGE FUNCTION SLANGE( NORM, M, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => SP REAL(WP) :: SLANGE 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 SLANGE MODULE PROCEDURE SLANGE1 END INTERFACE INTERFACE LA_GECON SUBROUTINE SGECON( NORM, N, A, LDA, ANORM, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGECON END INTERFACE INTERFACE LA_SYEV SUBROUTINE SSYEV( JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYEV END INTERFACE INTERFACE LA_SYEVD SUBROUTINE SSYEVD( JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, IWORK, & & LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYEVD END INTERFACE INTERFACE LA_SYEVR SUBROUTINE SSYEVR( 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 => SP 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 SSYEVR END INTERFACE INTERFACE LA_SYEVX SUBROUTINE SSYEVX( 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 => SP 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 SSYEVX END INTERFACE INTERFACE LA_SYGST SUBROUTINE SSYGST( ITYPE, UPLO, N, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYGST END INTERFACE INTERFACE LA_SYGV SUBROUTINE SSYGV( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYGV END INTERFACE INTERFACE LA_SYGVX SUBROUTINE SSYGVX( 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 => SP 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 SSYGVX END INTERFACE INTERFACE LA_SYGVD SUBROUTINE SSYGVD( ITYPE, JOBZ, UPLO, N, A, LDA, B, LDB, W, WORK,& & LWORK, IWORK, LIWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYGVD END INTERFACE INTERFACE LA_SYTRD SUBROUTINE SSYTRD( UPLO, N, A, LDA, D, E, TAU, WORK, LWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYTRD END INTERFACE INTERFACE LA_ORGTR SUBROUTINE SORGTR( UPLO, N, A, LDA, TAU, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SORGTR END INTERFACE INTERFACE LA_LANSY FUNCTION SLANSY( NORM, UPLO, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => SP REAL(WP) :: SLANSY 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 SLANSY END INTERFACE INTERFACE LA_POTRF SUBROUTINE SPOTRF( UPLO, N, A, LDA, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: LDA, N INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: A(LDA,*) END SUBROUTINE SPOTRF END INTERFACE INTERFACE LA_POCON SUBROUTINE SPOCON( UPLO, N, A, LDA, ANORM, RCOND, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPOCON 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 SLAGGE( M, N, KL, KU, D, A, LDA, ISEED, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SLAGGE END INTERFACE CONTAINS SUBROUTINE SGESV1( N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: LDA, LDB, NRHS, N INTEGER, INTENT(OUT) :: INFO INTEGER, INTENT(OUT) :: PIV(*) REAL(WP), INTENT(INOUT) :: A(LDA,*), B(*) INTERFACE SUBROUTINE SGESV( N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGESV END INTERFACE CALL SGESV( N, NRHS, A, LDA, PIV, B, LDB, INFO ) END SUBROUTINE SGESV1 SUBROUTINE SGESVX1( 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 => SP 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 SGESVX( 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 => SP 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 SGESVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SGESVX( 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 SGESVX1 SUBROUTINE SPOSV1( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPOSV( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPOSV END INTERFACE CALL SPOSV( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) END SUBROUTINE SPOSV1 FUNCTION SLANGE1( NORM, M, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => SP REAL(WP) :: SLANGE1 CHARACTER(LEN=1), INTENT(IN) :: NORM INTEGER, INTENT(IN) :: LDA, M, N REAL(WP), INTENT(IN) :: A( * ) REAL(WP), INTENT(OUT) :: WORK( * ) INTERFACE FUNCTION SLANGE( NORM, M, N, A, LDA, WORK ) USE LA_PRECISION, ONLY: WP => SP REAL(WP) :: SLANGE 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 SLANGE END INTERFACE SLANGE1 = SLANGE( NORM, M, N, A, LDA, WORK ) END FUNCTION SLANGE1 SUBROUTINE SGBSV1( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBSV( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBSV END INTERFACE CALL SGBSV( N, KL, KU, NRHS, AB, LDAB, PIV, B, LDB, INFO ) END SUBROUTINE SGBSV1 SUBROUTINE SGBSVX1( 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 => SP 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 SGBSVX( 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 => SP 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 SGBSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SGBSVX( 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 SGBSVX1 SUBROUTINE SGTSV1( N, NRHS, DL, D, DU, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: DL(*), D(*), DU(*), B(*) INTERFACE SUBROUTINE SGTSV( N, NRHS, DL, D, DU, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: DL(*), D(*), DU(*), B(LDB,*) END SUBROUTINE SGTSV END INTERFACE CALL SGTSV( N, NRHS, DL, D, DU, B, LDB, INFO ) END SUBROUTINE SGTSV1 SUBROUTINE SGTSVX1( 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 => SP 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 SGTSVX( 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 => SP 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 SGTSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SGTSVX( 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 SGTSVX1 SUBROUTINE SPOSVX1( 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 => SP 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 SPOSVX( 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 => SP 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 SPOSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SPOSVX( 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 SPOSVX1 SUBROUTINE SPPSV1( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP CHARACTER(LEN=1), INTENT(IN) :: UPLO INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: AP(*), B(*) INTERFACE SUBROUTINE SPPSV( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPSV END INTERFACE CALL SPPSV( UPLO, N, NRHS, AP, B, LDB, INFO ) END SUBROUTINE SPPSV1 SUBROUTINE SPPSVX1( FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B, & & LDB, X, LDX, RCOND, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPSVX( FACT, UPLO, N, NRHS, AP, AFP, EQUED, S, B,& & LDB, X, LDX, RCOND, FERR, BERR, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SPPSVX( 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 SPPSVX1 SUBROUTINE SPBSV1( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBSV( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBSV END INTERFACE CALL SPBSV( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) END SUBROUTINE SPBSV1 SUBROUTINE SPBSVX1( 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 => SP 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 SPBSVX( 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 => SP 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 SPBSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SPBSVX( 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 SPBSVX1 SUBROUTINE SPTSV1( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*) REAL(WP), INTENT(INOUT) :: E(*), B(*) INTERFACE SUBROUTINE SPTSV( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP INTEGER, INTENT(IN) :: NRHS, N, LDB INTEGER, INTENT(OUT) :: INFO REAL(WP), INTENT(INOUT) :: D(*) REAL(WP), INTENT(INOUT) :: E(*), B(LDB,*) END SUBROUTINE SPTSV END INTERFACE CALL SPTSV( N, NRHS, D, E, B, LDB, INFO ) END SUBROUTINE SPTSV1 SUBROUTINE SPTSVX1( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & RCOND, FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, & & LDX, RCOND, FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SPTSVX( FACT, N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & RCOND, LFERR, LBERR, WORK, INFO ) FERR = LFERR(1); BERR = LBERR(1) END SUBROUTINE SPTSVX1 SUBROUTINE SSYSV1( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYSV END INTERFACE CALL SSYSV( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, WORK, LWORK, & & INFO ) END SUBROUTINE SSYSV1 SUBROUTINE SSYSVX1( 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 => SP 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 SSYSVX( 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 => SP 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 SSYSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SSYSVX( 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 SSYSVX1 SUBROUTINE SSPSV1( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPSV END INTERFACE CALL SSPSV( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) END SUBROUTINE SSPSV1 SUBROUTINE SSPSVX1( FACT, UPLO, N, NRHS, A, AF, IPIV, B, LDB, X, & & LDX, RCOND, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPSVX( FACT, UPLO, N, NRHS, A, AF, IPIV, B, LDB, & & X, LDX, RCOND, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPSVX END INTERFACE REAL(WP) :: LFERR(1), LBERR(1) CALL SSPSVX( 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 SSPSVX1 SUBROUTINE SGELS1( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELS( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, & & LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELS END INTERFACE CALL SGELS( TRANS, M, N, NRHS, A, LDA, B, LDB, WORK, LWORK, & & INFO ) END SUBROUTINE SGELS1 SUBROUTINE SGELSY1( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSY END INTERFACE CALL SGELSY( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK, & & WORK, LWORK, INFO ) END SUBROUTINE SGELSY1 SUBROUTINE SGELSD1( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSD( M, N, NRHS, A, LDA, B, LDB, S, RCOND, & & RANK, WORK, LWORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSD END INTERFACE CALL SGELSD ( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, WORK,& & LWORK, IWORK, INFO ) END SUBROUTINE SGELSD1 SUBROUTINE SGELSX1( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSX( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, & & RANK, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSX END INTERFACE CALL SGELSX( M, N, NRHS, A, LDA, B, LDB, JPVT, RCOND, RANK, & & WORK, INFO ) END SUBROUTINE SGELSX1 SUBROUTINE SGELSS1( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, & & WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSS( M, N, NRHS, A, LDA, B, LDB, S, RCOND, & & RANK, WORK, LWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGELSS END INTERFACE CALL SGELSS( M, N, NRHS, A, LDA, B, LDB, S, RCOND, RANK, WORK, & & LWORK, INFO ) END SUBROUTINE SGELSS1 SUBROUTINE SGETRS1( TRANS, N, NRHS, A, LDA, PIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGETRS( TRANS, N, NRHS, A, LDA, PIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGETRS END INTERFACE CALL SGETRS( TRANS, N, NRHS, A, LDA, PIV, B, LDB, INFO ) END SUBROUTINE SGETRS1 SUBROUTINE SGERFS1( TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGERFS( TRANS, N, NRHS, A, LDA, AF, LDAF, PIV, & & B, LDB, X, LDX, FERR, BERR, WORK, & & IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGERFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL SGERFS( 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 SGERFS1 SUBROUTINE SGBTRS1( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, & & B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBTRS END INTERFACE CALL SGBTRS( TRANS, N, KL, KU, NRHS, AB, LDAB, IPIV, B, LDB, & & INFO ) END SUBROUTINE SGBTRS1 SUBROUTINE SGBRFS1( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, LDAFB, & & IPIV, B, LDB, X, LDX, FERR, BERR, WORK, IWORK,& & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBRFS( TRANS, N, KL, KU, NRHS, AB, LDAB, AFB, & & LDAFB, IPIV, B, LDB, X, LDX, FERR, BERR, & & WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGBRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL SGBRFS( 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 SGBRFS1 SUBROUTINE SGTTRS1( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGTTRS( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SGTTRS END INTERFACE CALL SGTTRS( TRANS, N, NRHS, DL, D, DU, DU2, IPIV, B, LDB, & & INFO ) END SUBROUTINE SGTTRS1 SUBROUTINE SGTRFS1( 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 => SP 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 SGTRFS( 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 => SP 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 SGTRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL SGTRFS( 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 SGTRFS1 SUBROUTINE SPOTRS1( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPOTRS( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPOTRS END INTERFACE CALL SPOTRS( UPLO, N, NRHS, A, LDA, B, LDB, INFO ) END SUBROUTINE SPOTRS1 SUBROUTINE SPORFS1( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPORFS( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, & & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPORFS END INTERFACE REAL(WP) :: BERR1(1), FERR1(1) CALL SPORFS( UPLO, N, NRHS, A, LDA, AF, LDAF, B, LDB, X, LDX, & & FERR1, BERR1, WORK, IWORK, INFO ) BERR = BERR1(1); FERR = FERR1(1) END SUBROUTINE SPORFS1 SUBROUTINE SPPTRS1( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPTRS( UPLO, N, NRHS, AP, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPTRS END INTERFACE CALL SPPTRS( UPLO, N, NRHS, AP, B, LDB, INFO ) END SUBROUTINE SPPTRS1 SUBROUTINE SPPRFS1( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR, & & BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPRFS( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPPRFS END INTERFACE REAL(WP) :: BERR1(1), FERR1(1) CALL SPPRFS( UPLO, N, NRHS, AP, AFP, B, LDB, X, LDX, FERR1, & & BERR1, WORK, IWORK, INFO ) BERR = BERR1(1); FERR = FERR1(1) END SUBROUTINE SPPRFS1 SUBROUTINE SPBTRS1( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBTRS( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBTRS END INTERFACE CALL SPBTRS( UPLO, N, KD, NRHS, AB, LDAB, B, LDB, INFO ) END SUBROUTINE SPBTRS1 SUBROUTINE SPBRFS1( UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBRFS( UPLO, N, KD, NRHS, AB, LDAB, AFB, LDAFB, & & B, LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPBRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL SPBRFS( 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 SPBRFS1 SUBROUTINE SPTTRS1( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTTRS( N, NRHS, D, E, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTTRS END INTERFACE CALL SPTTRS( N, NRHS, D, E, B, LDB, INFO ) END SUBROUTINE SPTTRS1 SUBROUTINE SPTRFS1( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR, & & BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTRFS( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, & & FERR, BERR, WORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SPTRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL SPTRFS( N, NRHS, D, E, DF, EF, B, LDB, X, LDX, FERR1, & & BERR1, WORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE SPTRFS1 SUBROUTINE SSYTRS1( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYTRS END INTERFACE CALL SSYTRS( UPLO, N, NRHS, A, LDA, IPIV, B, LDB, INFO ) END SUBROUTINE SSYTRS1 SUBROUTINE SSYRFS1( UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B, LDB,& & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYRFS( UPLO, N, NRHS, A, LDA, AF, LDAF, IPIV, B,& & LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSYRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL SSYRFS( 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 SSYRFS1 SUBROUTINE SSPTRS1( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPTRS ENDINTERFACE CALL SSPTRS( UPLO, N, NRHS, AP, IPIV, B, LDB, INFO ) END SUBROUTINE SSPTRS1 SUBROUTINE SSPRFS1( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, & & FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPRFS( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 SSPRFS END INTERFACE REAL(WP) :: FERR1(1), BERR1(1) CALL SSPRFS( UPLO, N, NRHS, AP, AFP, IPIV, B, LDB, X, LDX, & & FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE SSPRFS1 SUBROUTINE STRTRS1( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRTRS END INTERFACE CALL STRTRS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, & & INFO ) END SUBROUTINE STRTRS1 SUBROUTINE STRRFS1( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X,& & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STRRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL STRRFS( UPLO, TRANS, DIAG, N, NRHS, A, LDA, B, LDB, X, & & LDX, FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE STRRFS1 SUBROUTINE STPTRS1( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STPTRS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STPTRS END INTERFACE CALL STPTRS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, INFO ) END SUBROUTINE STPTRS1 SUBROUTINE STPRFS1( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, & & LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STPRFS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, & & X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STPRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL STPRFS( UPLO, TRANS, DIAG, N, NRHS, AP, B, LDB, X, LDX, & & FERR1, BERR1, WORK, IWORK, INFO ) FERR = FERR1(1); BERR = BERR1(1) END SUBROUTINE STPRFS1 SUBROUTINE STBTRS1( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB,& & B, LDB, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STBTRS END INTERFACE CALL STBTRS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, LDB, & & INFO ) END SUBROUTINE STBTRS1 SUBROUTINE STBRFS1( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB, B, & & LDB, X, LDX, FERR, BERR, WORK, IWORK, INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STBRFS( UPLO, TRANS, DIAG, N, KD, NRHS, AB, LDAB,& & B, LDB, X, LDX, FERR, BERR, WORK, IWORK, & & INFO ) USE LA_PRECISION, ONLY: WP => SP 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 STBRFS END INTERFACE REAL(WP) FERR1(1), BERR1(1) CALL STBRFS( 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 STBRFS1 END MODULE F77_LAPACK