| ▼LAPACK | |
| ►Linear solve, AX = B | |
| ►LU: General matrix, driver | |
| — full — | |
| gesv: factor and solve | CGESV computes the solution to system of linear equations A * X = B for GE matrices (simple driver) |
| gesvx: factor and solve, expert | |
| gesvxx: factor and solve, extra precise | |
| gesv: factor and solve, mixed precision | |
| — banded — | |
| gbsv: factor and solve | |
| gbsvx: factor and solve, expert | |
| gbsvxx: factor and solve, extra precise | |
| — tridiagonal — | |
| gtsv: factor and solve | |
| gtsvx: factor and solve, expert | |
| ►LU: computational routines (factor, cond, etc.) | |
| — full — | |
| gecon: condition number estimate | |
| getrf: triangular factor | |
| getrf2: triangular factor panel, recursive? | |
| getf2: triangular factor panel, level 2 | |
| getrs: triangular solve using factor | |
| getri: triangular inverse | |
| gerfs: iterative refinement | |
| gerfsx: iterative refinement, expert | |
| geequ: equilibration | |
| geequb: equilibration, power of 2 | |
| laqge: row/col scale matrix | |
| laswp: swap permutation | |
| getc2: triangular factor, with complete pivoting | |
| gesc2: triangular solve using factor, with complete pivoting | |
| latdf: Dif-estimate with complete pivoting LU, step in tgsen | |
| la_gercond: Skeel condition number estimate | |
| la_gerpvgrw: reciprocal pivot growth | |
| la_gerfsx_extended: step in gerfsx | |
| — banded — | |
| gbcon: condition number estimate | |
| gbtrf: triangular factor | |
| gbtf2: triangular factor, level 2 | |
| gbtrs: triangular solve using factor | |
| gbrfs: iterative refinement | |
| gbrfsx: iterative refinement, expert | |
| gbequ: equilibration | |
| gbequb: equilibration, power of 2 | |
| laqgb: row/col scale matrix | |
| la_gbrcond: Skeel condition number estimate | |
| la_gbrpvgrw: reciprocal pivot growth | |
| la_gbrfsx_extended: step in gbrfsx | |
| — tridiagonal — | |
| gtcon: condition number estimate | |
| gttrf: triangular factor | |
| gttrs: triangular solve using factor | |
| gtts2: triangular solve using factor | |
| gtrfs: iterative refinement | |
| ►Cholesky: Hermitian/symmetric positive definite matrix, driver | |
| — full — | |
| posv: factor and solve | |
| posvx: factor and solve, expert | |
| posvxx: factor and solve, extra precise | |
| posv: factor and solve, mixed precision | |
| — packed — | |
| ppsv: factor and solve | |
| ppsvx: factor and solve, expert | |
| — rectangular full packed (RFP) — | |
| pfsv: factor and solve [not available] | |
| — banded — | |
| pbsv: factor and solve | |
| pbsvx: factor and solve, expert | |
| — tridiagonal — | |
| ptsv: factor and solve | |
| ptsvx: factor and solve, expert | |
| ►Cholesky: computational routines (factor, cond, etc.) | |
| — full — | |
| pocon: condition number estimate | |
| potrf: triangular factor | |
| potrf2: triangular factor panel, recursive? | |
| potf2: triangular factor panel, level 2 | |
| pstrf: triangular factor, with pivoting | |
| pstf2: triangular factor, with pivoting panel, level 2 | |
| potrs: triangular solve using factor | |
| potri: triangular inverse | |
| porfs: iterative refinement | |
| porfsx: iterative refinement, expert | |
| poequ: equilibration | |
| poequb: equilibration, power of 2 | |
| laqhe: row/col scale matrix | |
| la_porcond: Skeel condition number estimate | |
| la_porpvgrw: reciprocal pivot growth | |
| la_porfsx_extended: step in porfsx | |
| — packed — | |
| ppcon: condition number estimate | |
| pptrf: triangular factor | |
| pptrs: triangular solve using factor | |
| pptri: triangular inverse | |
| pprfs: iterative refinement | |
| ppequ: equilibration | |
| laqhp: row/col scale matrix | |
| — rectangular full packed (RFP) — | |
| pftrf: triangular factor | |
| pftrs: triangular solve using factor | |
| pftri: triangular inverse | |
| — banded — | |
| pbcon: condition number estimate | |
| pbtrf: triangular factor | |
| pbtf2: triangular factor panel, level 2 | |
| pbtrs: triangular solve using factor | |
| pbrfs: iterative refinement | |
| pbequ: equilibration | |
| laqhb: row/col scale matrix | |
| — tridiagonal — | |
| ptcon: condition number estimate | |
| pttrf: triangular factor | |
| pttrs: triangular solve using factor | |
| ptts2: triangular solve using factor, unblocked | |
| ptrfs: iterative refinement | |
| ►LDL: Hermitian/symmetric indefinite matrix, driver | |
| — full, rook pivoting — | |
| {he,sy}sv: rook (v1) | |
| {he,sy}sv_rook: rook (v2) | |
| {he,sy}sv_rk: rook (v3) | |
| {he,sy}svx: rook (v1, expert) | |
| {he,sy}svxx: rook (v1, expert) | |
| — packed, rook pivoting — | |
| {hp,sp}sv: factor and solve | |
| {hp,sp}svx: factor and solve, expert | |
| — full, Aasen — | |
| {he,sy}sv_aa: Aasen | |
| {he,sy}sv_aa_2stage: Aasen, blocked 2-stage | |
| ►LDL: computational routines (factor, cond, etc.) | |
| — full, rook v1 — | |
| {he,sy}con: condition number estimate | |
| {he,sy}trf: triangular factor | |
| la{he,sy}f: step in hetrf | |
| {he,sy}tf2: triangular factor, level 2 | |
| {he,sy}trs: triangular solve using factor | |
| {he,sy}tri: triangular inverse | |
| {he,sy}rfs: iterative refinement | |
| {he,sy}rfsx: iterative refinement, expert | |
| {he,sy}equb: equilibration, power of 2 | |
| syconv: convert to/from L and D from hetrf | |
| {he,sy}con_3: condition number estimate | |
| {he,sy}tri2: inverse | |
| {he,sy}tri2x: inverse | |
| {he,sy}tri_3: inverse | |
| {he,sy}tri_3x: inverse | |
| {he,sy}trs2: solve using factor | |
| {he,sy}trs_3: solve using factor | |
| {he,sy}swapr: apply 2-sided permutation | |
| la_hercond: Skeel condition number estimate | |
| la_herfsx_extended: step in herfsx | |
| la_herpvgrw: reciprocal pivot growth | |
| — packed, rook v1 — | |
| {hp,sp}con: condition number estimate | |
| {hp,sp}trf: triangular factor | |
| {hp,sp}trs: triangular solve using factor | |
| {hp,sp}tri: triangular inverse | |
| {hp,sp}rfs: iterative refinement | |
| — full, rook v2 — | |
| {he,sy}con_rook: condition number estimate | |
| {he,sy}trf_rook: triangular factor | |
| la{he,sy}f_rook: triangular factor step | |
| {he,sy}tf2_rook: triangular factor, level 2 | |
| {he,sy}trs_rook: triangular solve using factor | |
| {he,sy}tri_rook: triangular inverse | |
| — full, rook v3 — | |
| {he,sy}trf_rk: triangular factor | |
| la{he,sy}f_rk: triangular factor step | |
| {he,sy}tf2_rk: triangular factor, level 2 | |
| syconvf: convert to/from hetrf to hetrf_rk format | |
| syconvf_rook: convert to/from hetrf_rook to hetrf_rk format | |
| — full, Aasen — | |
| {he,sy}trf_aa: triangular factor | |
| la{he,sy}f_aa: triangular factor partial factor | |
| {he,sy}trs_aa: triangular solve using factor | |
| — full, Aasen, blocked 2-stage — | |
| {he,sy}trf_aa_2stage: triangular factor | |
| {he,sy}trs_aa_2stage: triangular solve using factor | |
| ►Triangular computational routines (solve, cond, etc.) | |
| — full — | |
| trcon: condition number estimate | |
| trtrs: triangular solve | |
| latrs: triangular solve with robust scaling | |
| latrs3: triangular solve with robust scaling, level 3 | |
| trtri: triangular inverse | |
| trti2: triangular inverse, level 2 | |
| trrfs: triangular iterative refinement | |
| lauum: triangular multiply: U^H U | |
| lauu2: triangular multiply: U^H U, level 2 | |
| — packed — | |
| tpcon: condition number estimate | |
| tptrs: triangular solve | |
| latps: triangular solve with robust scaling | |
| tptri: triangular inverse | |
| tprfs: triangular iterative refinement | |
| — rectangular full packed (RFP) — | |
| tftri: triangular inverse, RFP | |
| — banded — | |
| tbcon: condition number estimate | |
| tbtrs: triangular solve | |
| latbs: triangular solve with scaling | |
| tbrfs: triangular iterative refinement | |
| ►Auxiliary routines | |
| lacn2: 1-norm estimate, e.g., || A^{-1} ||_1 in gecon | |
| lacon: 1-norm estimate, e.g., || A^{-1} ||_1 in gecon, old | |
| la_lin_berr: backward error | |
| ►Least squares | |
| ►Standard least squares, min || Ax - b ||_2 | |
| gels: least squares using QR/LQ | |
| gelst: least squares using QR/LQ with T matrix | |
| gelss: least squares using SVD, QR iteration | |
| gelsd: least squares using SVD, divide and conquer | |
| gelsy: least squares using complete orthogonal factor | |
| getsls: least squares using tall-skinny QR/LQ | |
| ►Constrained least squares | |
| gglse: equality-constrained least squares | |
| ggglm: Gauss-Markov linear model | |
| ►Auxiliary routines | |
| laic1: condition estimate, step in gelsy | |
| lals0: back multiplying factors, step in gelsd | |
| lalsa: SVD of coefficient matrix, step in gelsd | |
| lalsd: uses SVD for least squares, step in gelsd | |
| ►Orthogonal/unitary factors (QR, CS, etc.) | |
| ►QR | |
| — flexible — | |
| geqr: QR factor, flexible | |
| gemqr: multiply by Q from geqr | |
| — classic — | |
| geqrf: QR factor | |
| geqr2: QR factor, level 2 | |
| {un,or}gqr: generate explicit Q from geqrf | |
| {un,or}g2r: generate explicit Q from geqrf, level 2 | |
| {un,or}mqr: multiply by Q from geqrf | |
| {un,or}m2r: multiply by Q from geqrf, level 2 | |
| — with T — | |
| geqrt: QR factor, with T | |
| geqrt2: QR factor, with T, level 2 | |
| geqrt3: QR factor, with T, recursive panel | |
| gemqrt: multiply by Q from geqrt | |
| — positive — | |
| geqrfp: QR factor, diag( R ) ≥ 0 | |
| geqr2p: QR factor, diag( R ) ≥ 0, level 2 | |
| ►QR with pivoting | |
| geqp3: QR factor with pivoting, level 3 | |
| laqp2: step of geqp3 | |
| laqps: step of geqp3 | |
| ►QR, tall-skinny | |
| latsqr: tall-skinny QR factor | |
| {un,or}gtsqr: generate Q from latsqr | |
| {un,or}gtsqr_row: generate Q from latsqr | |
| larfb_gett: step in ungtsqr_row | |
| lamtsqr: multiply by Q from latsqr | |
| getsqrhrt: tall-skinny QR factor, with Householder reconstruction | |
| {un,or}hr_col: Householder reconstruction | |
| la{un,or}hr_col_getrfnp: LU factor without pivoting | |
| la{un,or}hr_col_getrfnp2: LU factor without pivoting, level 2 | |
| ►QR, triangular-pentagonal | |
| tpqrt: QR factor | |
| tpqrt2: QR factor, level 2 | |
| tpmqrt: applies Q | |
| tprfb: applies Q (like larfb) | |
| ►Generalized QR | |
| ggqrf: Generalized QR factor | |
| ►LQ | |
| — flexible — | |
| gelq: LQ factor, flexible | |
| gemlq: multiply by Q from gelq | |
| — classic — | |
| gelqf: LQ factor | |
| gelq2: LQ factor, level 2 | |
| {un,or}glq: generate explicit Q from gelqf | |
| {un,or}gl2: generate explicit Q, level 2, step in unglq | |
| {un,or}mlq: multiply by Q from gelqf | |
| {un,or}ml2: multiply by Q, level 2, step in unmlq | |
| — with T — | |
| gelqt: LQ factor, with T | |
| gelqt3: LQ factor, with T, recursive | |
| gemlqt: multiply by Q from gelqt | |
| ►LQ, short-wide | |
| laswlq: short-wide LQ factor | |
| lamswlq: multiply by Q from laswlq | |
| ►LQ, triangular-pentagonal | |
| tplqt: QR factor | |
| tplqt2: QR factor, level 2 | |
| tpmlqt: applies Q | |
| ►QL | |
| geqlf: QL factor | |
| geql2: QL factor, level 2 | |
| {un,or}gql: generate explicit Q from geqlf | |
| {un,or}mql: multiply by Q from geqlf | |
| {un,or}g2l: step in ungql | |
| {un,or}m2l: step in unmql | |
| ►RQ | |
| gerqf: RQ factor | |
| gerq2: RQ factor, level 2 | |
| {un,or}grq: generate explicit Q from gerqf | |
| {un,or}mrq: multiply by Q from gerqf | |
| {un,or}mr2: step in unmrq | |
| {un,or}gr2: step in ungrq | |
| ►Generalized RQ | |
| ggrqf: Generalized RQ factor | |
| ►RZ | |
| tzrzf: RZ factor | |
| latrz: RZ factor step | |
| {un,or}mrz: multiply by Z from tzrzf | |
| {un,or}mr3: step in unmrz | |
| larz: apply reflector | |
| larzb: apply block reflector | |
| larzt: generate T matrix | |
| ►Cosine-Sine (CS) decomposition | |
| bbcsd: ?? | |
| {un,or}csd: ?? | |
| {un,or}csd2by1: ?? | |
| {un,or}bdb: bidiagonalize partitioned unitary matrix, step in uncsd | |
| {un,or}bdb1: step in uncsd2by1 | |
| {un,or}bdb2: step in uncsd2by1 | |
| {un,or}bdb3: step in uncsd2by1 | |
| {un,or}bdb4: step in uncsd2by1 | |
| {un,or}bdb5: step in uncsd2by1 | |
| {un,or}bdb6: step in uncsd2by1 | |
| lapmr: permute rows | |
| lapmt: permute cols | |
| ►Householder reflectors | |
| larf: apply Householder reflector | |
| larfx: apply Householder reflector, unrolled | |
| larfy: apply Householder reflector symmetrically (2-sided) | |
| larfb: apply block Householder reflector | |
| larfg: generate Householder reflector | |
| larfgp: generate Householder reflector, beta ≥ 0 | |
| larft: generate T matrix | |
| ►Givens/Jacobi plane rotations | |
| lartg: generate plane rotation, more accurate than BLAS rot | |
| lartgp: generate plane rotation, more accurate than BLAS rot | |
| lasr: apply series of plane rotations | |
| largv: generate vector of plane rotations | |
| lartv: apply vector of plane rotations to vectors | |
| lar2v: apply vector of plane rotations to 2x2 matrices | |
| lacrt: apply plane rotation (unused?) | |
| ►Non-symmetric eigenvalues | |
| ►Standard eig driver, AV = VΛ | |
| geev: eig | |
| geevx: eig, expert | |
| gees: Schur form | |
| geesx: Schur form, expert | |
| ►Generalized eig driver | |
| ggev3: eig | |
| ggev: eig, unblocked | |
| ggevx: eig, expert | |
| gges3: Schur form | |
| gges: Schur form, unblocked | |
| ggesx: Schur form, expert | |
| DMD driver, Dynamic Mode Decomposition | |
| ►Eig computational routines | |
| gebal: balance matrix | |
| gehrd: reduction to Hessenberg | |
| gehd2: reduction to Hessenberg, level 2 | |
| lahr2: step in gehrd | |
| {un,or}ghr: generate Q from gehrd | |
| {un,or}mhr: multiply by Q from gehrd | |
| gebak: back-transform eigvec | |
| hseqr: Hessenberg eig, QR iteration | |
| hsein: Hessenberg inverse iteration for eigvec | |
| trevc: eigenvectors of triangular Schur form, old | |
| trevc3: eigenvectors of triangular Schur form, blocked | |
| laln2: 1x1 or 2x2 solve, step in trevc | |
| trsyl: Sylvester equation | |
| trsyl3: Sylvester equation, level 3 | |
| lasy2: Sylvester equation | |
| trsna: eig condition numbers | |
| laqtr: quasi-triangular solve | |
| trexc: reorder Schur form | |
| trsen: reorder Schur form | |
| laexc: reorder Schur form | |
| lanv2: 2x2 Schur factor | |
| — hseqr auxiliary — | |
| laein: eigvec by Hessenberg inverse iteration | |
| lahqr: eig of Hessenberg, step in hseqr | |
| laqr0: eig of Hessenberg, step in hseqr | |
| laqr1: step in hseqr | |
| laqr2: step in hseqr | |
| laqr3: step in hseqr | |
| laqr4: eig of Hessenberg, step in hseqr | |
| laqr5: step in hseqr | |
| iparmq: set parameters for hseqr | |
| — ggev3, gges3 auxiliary — | |
| laqz0: step in ggev3, gges3 | |
| laqz1: step in ggev3, gges3 | |
| laqz2: step in ggev3, gges3 | |
| laqz3: step in ggev3, gges3 | |
| laqz4: step in ggev3, gges3 | |
| ►Generalized eig computational routines | |
| ggbal: balance matrix | |
| gghrd: reduction to Hessenberg | |
| gghd3: reduction to Hessenberg, level 3 | |
| hgeqz: generalized Hessenberg eig | |
| ggbak: back-transform eigvec | |
| tgsen: reorder generalized Schur form | |
| tgsna: reciprocal cond est | |
| tgsyl: Sylvester equation | |
| tgsy2: Sylvester equation panel (?) | |
| {un,or}m22: multiply by banded Q, step in gghd3 | |
| lagv2: 2x2 generalized Schur factor | |
| tgevc: eigvec of pair of matrices | |
| tgexc: reorder generalized Schur form | |
| tgex2: reorder generalized Schur form | |
| ►Hermitian/symmetric eigenvalues | |
| ►Standard eig driver, AV = VΛ | |
| — full — | |
| {he,sy}ev: eig, QR iteration | |
| {he,sy}evd: eig, divide and conquer | |
| {he,sy}evr: eig, MRRR | |
| {he,sy}evx: eig, bisection | |
| — full, 2-stage — | |
| {he,sy}ev_2stage: eig, QR iteration | |
| {he,sy}evd_2stage: eig, divide and conquer | |
| {he,sy}evr_2stage: eig, MRRR | |
| {he,sy}evx_2stage: eig, bisection | |
| — packed — | |
| {hp,sp}ev: eig, QR iteration | |
| {hp,sp}evd: eig, divide and conquer | |
| {hp,sp}evx: eig, bisection | |
| — banded — | |
| {hb,sb}ev: eig, QR iteration | |
| {hb,sb}evd: eig, divide and conquer | |
| {hb,sb}evx: eig, bisection | |
| — banded, 2nd-stage — | |
| {hb,sb}ev_2stage: eig, QR iteration | |
| {hb,sb}evd_2stage: eig, divide and conquer | |
| {hb,sb}evx_2stage: eig, bisection | |
| — tridiagonal — | |
| stev: eig, QR iteration | |
| stevd: eig, divide and conquer | |
| stevr: eig, MRRR | |
| stevx: eig, bisection | |
| pteqr: eig, positive definite tridiagonal | |
| stebz: eig, Kahan | |
| sterf: eig, QR iteration | |
| stedc: eig, divide and conquer | |
| stegr: eig, bisection, see stemr | |
| stein: eig, inverse iteration | |
| stemr: eig, relatively robust representation (RRR) | |
| steqr: eig, QR iteration | |
| ►Generalized eig driver, AV = BVΛ, etc. | |
| — full — | |
| {he,sy}gv: eig, QR iteration | |
| {he,sy}gv_2stage: eig, QR iteration, 2-stage | |
| {he,sy}gvd: eig, divide and conquer | |
| {he,sy}gvx: eig, bisection | |
| — packed — | |
| {hp,sp}gv: eig, QR iteration | |
| {hp,sp}gvd: eig, divide and conquer | |
| {hp,sp}gvx: eig, bisection | |
| — banded — | |
| {hb,sb}gv: eig, QR iteration | |
| {hb,sb}gvd: eig, divide and conquer | |
| {hb,sb}gvx: eig, bisection | |
| ►Eig computational routines | |
| — full — | |
| disna: eig condition numbers | |
| {he,sy}trd: reduction to tridiagonal | |
| {he,sy}td2: reduction to tridiagonal, level 2 | |
| latrd: step in hetrd | |
| {un,or}gtr: generate Q from hetrd | |
| {un,or}mtr: multiply by Q from hetrd | |
| {he,sy}trd_2stage: reduction to tridiagonal, 2-stage | |
| {he,sy}trd_he2hb: full to band (1st stage) | |
| {he,sy}trd_hb2st: band to tridiagonal (2nd stage) | |
| {hb,sb}2st_kernels: band to tridiagonal (2nd stage) | |
| lae2: 2x2 eig, step in steqr, stemr | |
| laesy: 2x2 eig | |
| laev2: 2x2 eig | |
| lagtf: LU factor of (T - λI) | |
| lagts: LU solve of (T - λI) x = y | |
| — packed — | |
| {hp,sp}trd: reduction to tridiagonal | |
| {up,op}gtr: generate Q from hetrd | |
| {up,op}mtr: multiply by Q from hptrd | |
| — banded — | |
| {hb,sb}trd: reduction to tridiagonal | |
| ►Generalized eig computational routines | |
| {he,sy}gst: reduction to standard form | |
| {he,sy}gs2: reduction to standard form, level 2 | |
| {hp,sp}gst: reduction to standard form, packed | |
| {hb,sb}gst: reduction to standard form, banded | |
| pbstf: split Cholesky factor, use with hbgst | |
| lag2: 2x2 eig | |
| ►tridiag bisection routines | |
| laebz: counts eigvals <= value | |
| laneg: Sturm count | |
| ►tridiag divide and conquer (D&C) routines | |
| laed0: D&C step: top level solver | |
| laed1: D&C step: merge subproblems | |
| laed2: D&C step: deflation | |
| laed3: D&C step: secular equation | |
| laed4: D&C step: secular equation nonlinear solver | |
| laed5: D&C step: secular equation, 2x2 | |
| laed6: D&C step: secular equation Newton step | |
| lamrg: permutation to merge 2 sorted lists | |
| — eig value only or update Q — | |
| laed7: D&C step: merge subproblems | |
| laed8: D&C step: deflation | |
| laed9: D&C step: secular equation | |
| laeda: D&C step: z vector | |
| ►tridiag RRR routines | |
| larra: step in stemr | |
| larrb: step in stemr | |
| larrc: step in stemr | |
| larrd: step in stemr, tridiag eig | |
| larre: step in stemr | |
| larrf: step in stemr, find relative robust representation (RRR) | |
| larrj: step in stemr, refine eigval estimates | |
| larrk: step in stemr, compute one eigval | |
| larrr: step in stemr, test to do expensive tridiag eig algorithm | |
| larrv: eig tridiagonal, step in stemr & stegr | |
| lar1v: step in larrv, hence stemr & stegr | |
| ►Singular Value Decomposition (SVD) | |
| ►Standard SVD driver, A = UΣV^H | |
| — full — | |
| gesvd: SVD, QR iteration | |
| gesvdq: SVD, QR with pivoting | |
| gesdd: SVD, divide and conquer | |
| gesvdx: SVD, bisection | |
| gejsv: SVD, Jacobi, high-level | |
| gesvj: SVD, Jacobi, low-level | |
| — bidiagonal — | |
| bdsqr: bidiagonal SVD, QR iteration (dqds) | |
| bdsdc: bidiagonal SVD, divide and conquer | |
| bdsvdx: bidiagonal SVD, bisection | |
| ►Generalized SVD driver | |
| ggsvd3: SVD, QR iteration | |
| ►SVD computational routines | |
| gebrd: reduction to bidiagonal | |
| gebd2: reduction to bidiagonal, level 2 | |
| labrd: step in gebrd | |
| gbbrd: band to bidiagonal | |
| {un,or}gbr: generate Q, P from gebrd | |
| {un,or}mbr: multiply by Q, P from gebrd | |
| — auxiliary routines — | |
| gsvj0: step in gesvj | |
| gsvj1: step in gesvj | |
| las2: 2x2 triangular SVD | |
| lasv2: 2x2 triangular SVD | |
| lartgs: generate plane rotation for bidiag SVD | |
| ►Generalized SVD computational routines | |
| ggsvp3: step in ggsvd | |
| tgsja: generalized SVD of trapezoidal matrices, step in ggsvd3 | |
| lags2: 2x2 orthogonal factor, step in tgsja | |
| lapll: linear dependence of 2 vectors | |
| ►bidiag QR iteration routines | |
| lasq1: dqds step | |
| lasq2: dqds step | |
| lasq3: dqds step | |
| lasq4: dqds step | |
| lasq5: dqds step | |
| lasq6: dqds step | |
| ►bidiag D&C routines | |
| lasd0: D&C step: top level solver | |
| lasdt: D&C step: tree | |
| lasd1: D&C step: merge subproblems | |
| lasd2: D&C step: deflation | |
| lasd3: D&C step: secular equation | |
| lasd4: D&C step: secular equation nonlinear solver | |
| lasd5: D&C step: secular equation, 2x2 | |
| lasdq: D&C step: leaf using bdsqr | |
| — singular values only or factored form — | |
| lasda: D&C step: top level solver | |
| lasd6: D&C step: merge subproblems | |
| lasd7: D&C step: deflation | |
| lasd8: D&C step: secular equation | |
| ►BLAS-like | |
| ►Initialize, copy, convert | |
| laset: set matrix | |
| larnv: random vector | |
| laruv: random uniform vector | |
| lacpy: copy matrix | |
| lacp2: general matrix, convert real to complex | |
| <em>lag2</em>: general matrix, convert double <=> single | |
| <em>lat2</em>: triangular matrix, convert double <=> single | |
| tfttp: triangular matrix, RFP (tf) to packed (tp) | |
| tfttr: triangular matrix, RFP (tf) to full (tr) | |
| tpttf: triangular matrix, packed (tp) to RFP (tf) | |
| tpttr: triangular matrix, packed (tp) to full (tr) | |
| trttf: triangular matrix, full (tr) to RFP (tf) | |
| trttp: triangular matrix, full (tr) to packed (tp) | |
| ►Matrix norm | |
| lange: general matrix | |
| langb: general matrix, banded | |
| langt: general matrix, tridiagonal | |
| lanhs: Hessenberg | |
| lan{he,sy}: Hermitian/symmetric matrix | |
| lan{hf,sf}: Hermitian/symmetric matrix, RFP | |
| lan{hp,sp}: Hermitian/symmetric matrix, packed | |
| lan{hb,sb}: Hermitian/symmetric matrix, banded | |
| lan{ht,st}: Hermitian/symmetric matrix, tridiagonal | |
| lantr: triangular matrix | |
| lantp: triangular matrix, packed | |
| lantb: triangular matrix, banded | |
| ►Scalar operations | |
| isnan: test for NaN | |
| laisnan: test for NaN, unoptimized | |
| ladiv: complex divide | |
| lapy2: robust sqrt( x^2 + y^2 ) | |
| lapy3: robust sqrt( x^2 + y^2 + z^2 ) | |
| larmm: scale factor to avoid overflow, step in latrs | |
| ►Level 1 BLAS-like vector ops | |
| lacgv: conjugate vector | |
| lasrt: sort vector | |
| lassq: sum-of-squares, avoiding over/underflow | |
| rscl: scale vector by reciprocal | |
| ►Level 2 BLAS-like matrix-vector ops | |
| ilalc: find non-zero col | |
| ilalr: find non-zero row | |
| lascl: scale matrix | |
| la_geamv: matrix-vector multiply |A| * |x|, general | |
| la_gbamv: matrix-vector multiply |A| * |x|, general banded | |
| la_heamv: matrix-vector multiply |A| * |x|, Hermitian/symmetric | |
| lascl2: diagonal scale matrix, A = D A | |
| larscl2: reciprocal diagonal scale matrix, A = D^{-1} A | |
| la_wwaddw: add to double-double or single-single vector | |
| ►Level 3 BLAS-like matrix-matrix ops | |
| lagtm: tridiagonal matrix-matrix multiply | |
| lacrm: complex * real matrix-matrix multiply | |
| larcm: real * complex matrix-matrix multiply | |
| hfrk: Hermitian rank-k update, RFP format | |
| tfsm: triangular-matrix solve, RFP format | |
| ►Auxiliary routines | |
| ►Other auxiliary routines | |
| lsame: string comparison | |
| lsamen: string comparison | |
| roundup_lwork: fix rounding integer to float | |
| second: wall clock timer | |
| ►Parameters | |
| lamch: machine parameters | |
| lamc1: ?? | |
| lamc2: ?? | |
| lamc3: ?? | |
| lamc4: ?? | |
| lamc5: ?? | |
| labad: over/underflow on obsolete pre-IEEE machines | |
| ilaver: LAPACK version | |
| ilaenv: tuning parameters | |
| ilaenv2stage: tuning parameters for 2-stage eig | |
| iparam2stage: sets parameters for 2-stage eig | |
| ieeeck: verify inf and NaN are safe | |
| la_constants: Fortran 95 module of constants | |
| — BLAST constants — | |
| iladiag: diag string to BLAST const | |
| ilaprec: precision string to BLAST const | |
| ilatrans: trans string to BLAST const | |
| ilauplo: uplo string to BLAST const | |
| la_transtype: BLAST const to string | |
| ►Error reporting | |
| xerbla: error reporting | |
| xerbla_array: error reporting, callable from C | |
| ▼BLAS | |
| ►Scalar operations | |
| abs1: | real( x ) | + | imag( x ) | | |
| ►Level 1 BLAS: vector ops | |
| asum: sum | real( x_i ) | + | imag( x_i ) | | |
| sum1: sum | x_i | (in LAPACK) | |
| axpy: y = ax + y | |
| copy: y = x | |
| dot: x^H x and x^T x | |
| iamax: argmax_i | real( x_i ) | + | imag( x_i ) | | |
| imax1: argmax_i | x_i | (in LAPACK) | |
| nrm2: || x ||_2 | |
| scal: x = alpha x | |
| swap: x <=> y | |
| — Givens/Jacobi plane rotations — | |
| rot: apply plane rotation ([cz]rot in LAPACK) | |
| rotg: generate plane rotation (cf. lartg) | |
| rotm: apply modified (fast) plane rotation | |
| rotmg: generate modified (fast) plane rotation | |
| ►Level 2 BLAS: matrix-vector ops | |
| — full — | |
| gemv: general matrix-vector multiply | |
| ger: general matrix rank-1 update | |
| {he,sy}mv: Hermitian/symmetric matrix-vector multiply ([cz]symv in LAPACK) | |
| {he,sy}r: Hermitian/symmetric rank-1 update | |
| {he,sy}r2: Hermitian/symmetric rank-2 update | |
| trmv: triangular matrix-vector multiply | |
| trsv: triangular matrix-vector solve | |
| — packed — | |
| {hp,sp}mv: Hermitian/symmetric matrix-vector multiply | |
| {hp,sp}r: Hermitian/symmetric rank-1 update | |
| {hp,sp}r2: Hermitian/symmetric rank-2 update | |
| tpmv: triangular matrix-vector multiply | |
| tpsv: triangular matrix-vector solve | |
| — banded — | |
| gbmv: general matrix-vector multiply | |
| {hb,sb}mv: Hermitian/symmetric matrix-vector multiply | |
| tbmv: triangular matrix-vector multiply | |
| tbsv: triangular matrix-vector solve | |
| ►Level 3 BLAS: matrix-matrix ops | |
| gemm: general matrix-matrix multiply | |
| {he,sy}mm: Hermitian/symmetric matrix-matrix multiply | |
| {he,sy}rk: Hermitian/symmetric rank-k update | |
| {he,sy}r2k: Hermitian/symmetric rank-2k update | |
| trmm: triangular matrix-matrix multiply | |
| trsm: triangular matrix-matrix solve | |
1.9.4