/** @defgroup lapack_top LAPACK @{ @defgroup solve_top Linear solve, AX = B @{ @defgroup gesv_driver_grp LU: General matrix, driver @{ @defgroup gesv_driver --- full --- @defgroup gesv gesv: factor and solve @defgroup gesvx gesvx: factor and solve, expert @defgroup gesvxx gesvxx: factor and solve, extra precise @defgroup gesv_mixed gesv: factor and solve, mixed precision @defgroup gbsv_driver --- banded --- @defgroup gbsv gbsv: factor and solve @defgroup gbsvx gbsvx: factor and solve, expert @defgroup gbsvxx gbsvxx: factor and solve, extra precise @defgroup gtsv_driver --- tridiagonal --- @defgroup gtsv gtsv: factor and solve @defgroup gtsvx gtsvx: factor and solve, expert @} @defgroup gesv_comp_grp LU: computational routines (factor, cond, etc.) @{ @defgroup gesv_comp --- full --- @defgroup gecon gecon: condition number estimate @defgroup getrf getrf: triangular factor @defgroup getrf2 getrf2: triangular factor panel, recursive? @defgroup getf2 getf2: triangular factor panel, level 2 @defgroup getrs getrs: triangular solve using factor @defgroup getri getri: triangular inverse @defgroup gerfs gerfs: iterative refinement @defgroup gerfsx gerfsx: iterative refinement, expert @defgroup geequ geequ: equilibration @defgroup geequb geequb: equilibration, power of 2 @defgroup laqge laqge: row/col scale matrix @defgroup laswp laswp: swap permutation @defgroup getc2 getc2: triangular factor, with complete pivoting @defgroup gesc2 gesc2: triangular solve using factor, with complete pivoting @defgroup latdf latdf: Dif-estimate with complete pivoting LU, step in tgsen @defgroup la_gercond la_gercond: Skeel condition number estimate @defgroup la_gerpvgrw la_gerpvgrw: reciprocal pivot growth @defgroup la_gerfsx_extended la_gerfsx_extended: step in gerfsx @defgroup gbsv_comp --- banded --- @defgroup gbcon gbcon: condition number estimate @defgroup gbtrf gbtrf: triangular factor @defgroup gbtf2 gbtf2: triangular factor, level 2 @defgroup gbtrs gbtrs: triangular solve using factor @defgroup gbrfs gbrfs: iterative refinement @defgroup gbrfsx gbrfsx: iterative refinement, expert @defgroup gbequ gbequ: equilibration @defgroup gbequb gbequb: equilibration, power of 2 @defgroup laqgb laqgb: row/col scale matrix @defgroup la_gbrcond la_gbrcond: Skeel condition number estimate @defgroup la_gbrpvgrw la_gbrpvgrw: reciprocal pivot growth @defgroup la_gbrfsx_extended la_gbrfsx_extended: step in gbrfsx @defgroup gtsv_comp --- tridiagonal --- @defgroup gtcon gtcon: condition number estimate @defgroup gttrf gttrf: triangular factor @defgroup gttrs gttrs: triangular solve using factor @defgroup gtts2 gtts2: triangular solve using factor @defgroup gtrfs gtrfs: iterative refinement @} @defgroup posv_driver_grp Cholesky: Hermitian/symmetric positive definite matrix, driver @{ @defgroup posv_driver --- full --- @defgroup posv posv: factor and solve @defgroup posvx posvx: factor and solve, expert @defgroup posvxx posvxx: factor and solve, extra precise @defgroup posv_mixed posv: factor and solve, mixed precision @defgroup ppsv_driver --- packed --- @defgroup ppsv ppsv: factor and solve @defgroup ppsvx ppsvx: factor and solve, expert @defgroup pfsv_driver --- rectangular full packed (RFP) --- @defgroup pfsv pfsv: factor and solve [not available] @defgroup pbsv_driver --- banded --- @defgroup pbsv pbsv: factor and solve @defgroup pbsvx pbsvx: factor and solve, expert @defgroup ptsv_driver --- tridiagonal --- @defgroup ptsv ptsv: factor and solve @defgroup ptsvx ptsvx: factor and solve, expert @} @defgroup posv_comp_grp Cholesky: computational routines (factor, cond, etc.) @{ @defgroup posv_comp --- full --- @defgroup pocon pocon: condition number estimate @defgroup potrf potrf: triangular factor @defgroup potrf2 potrf2: triangular factor panel, recursive? @defgroup potf2 potf2: triangular factor panel, level 2 @defgroup pstrf pstrf: triangular factor, with pivoting @defgroup pstf2 pstf2: triangular factor, with pivoting panel, level 2 @defgroup potrs potrs: triangular solve using factor @defgroup potri potri: triangular inverse @defgroup porfs porfs: iterative refinement @defgroup porfsx porfsx: iterative refinement, expert @defgroup poequ poequ: equilibration @defgroup poequb poequb: equilibration, power of 2 @defgroup laqhe laqhe: row/col scale matrix @defgroup la_porcond la_porcond: Skeel condition number estimate @defgroup la_porpvgrw la_porpvgrw: reciprocal pivot growth @defgroup la_porfsx_extended la_porfsx_extended: step in porfsx @defgroup ppsv_comp --- packed --- @defgroup ppcon ppcon: condition number estimate @defgroup pptrf pptrf: triangular factor @defgroup pptrs pptrs: triangular solve using factor @defgroup pptri pptri: triangular inverse @defgroup pprfs pprfs: iterative refinement @defgroup ppequ ppequ: equilibration @defgroup laqhp laqhp: row/col scale matrix @defgroup pfsv_comp --- rectangular full packed (RFP) --- @defgroup pftrf pftrf: triangular factor @defgroup pftrs pftrs: triangular solve using factor @defgroup pftri pftri: triangular inverse @defgroup pbsv_comp --- banded --- @defgroup pbcon pbcon: condition number estimate @defgroup pbtrf pbtrf: triangular factor @defgroup pbtf2 pbtf2: triangular factor panel, level 2 @defgroup pbtrs pbtrs: triangular solve using factor @defgroup pbrfs pbrfs: iterative refinement @defgroup pbequ pbequ: equilibration @defgroup laqhb laqhb: row/col scale matrix @defgroup ptsv_comp --- tridiagonal --- @defgroup ptcon ptcon: condition number estimate @defgroup pttrf pttrf: triangular factor @defgroup pttrs pttrs: triangular solve using factor @defgroup ptts2 ptts2: triangular solve using factor, unblocked @defgroup ptrfs ptrfs: iterative refinement @} @defgroup hesv_driver_grp LDL: Hermitian/symmetric indefinite matrix, driver @{ @defgroup hesv_driver --- full, rook pivoting --- @defgroup hesv {he,sy}sv: rook (v1) @defgroup hesv_rook {he,sy}sv_rook: rook (v2) @defgroup hesv_rk {he,sy}sv_rk: rook (v3) @defgroup hesvx {he,sy}svx: rook (v1, expert) @defgroup hesvxx {he,sy}svxx: rook (v1, expert) @defgroup hpsv_driver --- packed, rook pivoting --- @defgroup hpsv {hp,sp}sv: factor and solve @defgroup hpsvx {hp,sp}svx: factor and solve, expert @defgroup hesv_aa_driver --- full, Aasen --- @defgroup hesv_aa {he,sy}sv_aa: Aasen @defgroup hesv_aa_2stage {he,sy}sv_aa_2stage: Aasen, blocked 2-stage @} @defgroup hesv_comp_grp LDL: computational routines (factor, cond, etc.) @{ @defgroup hesv_comp_v1 --- full, rook v1 --- @defgroup hecon {he,sy}con: condition number estimate @defgroup hetrf {he,sy}trf: triangular factor @defgroup lahef la{he,sy}f: step in hetrf @defgroup hetf2 {he,sy}tf2: triangular factor, level 2 @defgroup hetrs {he,sy}trs: triangular solve using factor @defgroup hetri {he,sy}tri: triangular inverse @defgroup herfs {he,sy}rfs: iterative refinement @defgroup herfsx {he,sy}rfsx: iterative refinement, expert @defgroup heequb {he,sy}equb: equilibration, power of 2 @defgroup syconv syconv: convert to/from L and D from hetrf @defgroup hecon_3 {he,sy}con_3: condition number estimate @defgroup hetri2 {he,sy}tri2: inverse @defgroup hetri2x {he,sy}tri2x: inverse @defgroup hetri_3 {he,sy}tri_3: inverse @defgroup hetri_3x {he,sy}tri_3x: inverse @defgroup hetrs2 {he,sy}trs2: solve using factor @defgroup hetrs_3 {he,sy}trs_3: solve using factor @defgroup heswapr {he,sy}swapr: apply 2-sided permutation @defgroup la_hercond la_hercond: Skeel condition number estimate @defgroup la_herfsx_extended la_herfsx_extended: step in herfsx @defgroup la_herpvgrw la_herpvgrw: reciprocal pivot growth @defgroup hpsv_comp --- packed, rook v1 --- @defgroup hpcon {hp,sp}con: condition number estimate @defgroup hptrf {hp,sp}trf: triangular factor @defgroup hptrs {hp,sp}trs: triangular solve using factor @defgroup hptri {hp,sp}tri: triangular inverse @defgroup hprfs {hp,sp}rfs: iterative refinement @defgroup hesv_comp_v2 --- full, rook v2 --- @defgroup hecon_rook {he,sy}con_rook: condition number estimate @defgroup hetrf_rook {he,sy}trf_rook: triangular factor @defgroup lahef_rook la{he,sy}f_rook: triangular factor step @defgroup hetf2_rook {he,sy}tf2_rook: triangular factor, level 2 @defgroup hetrs_rook {he,sy}trs_rook: triangular solve using factor @defgroup hetri_rook {he,sy}tri_rook: triangular inverse @defgroup hesv_comp_v3 --- full, rook v3 --- @defgroup hetrf_rk {he,sy}trf_rk: triangular factor @defgroup lahef_rk la{he,sy}f_rk: triangular factor step @defgroup hetf2_rk {he,sy}tf2_rk: triangular factor, level 2 @defgroup syconvf syconvf: convert to/from hetrf to hetrf_rk format @defgroup syconvf_rook syconvf_rook: convert to/from hetrf_rook to hetrf_rk format @defgroup hesv_comp_aasen --- full, Aasen --- @defgroup hetrf_aa {he,sy}trf_aa: triangular factor @defgroup lahef_aa la{he,sy}f_aa: triangular factor partial factor @defgroup hetrs_aa {he,sy}trs_aa: triangular solve using factor @defgroup hesv_comp_aasen2 --- full, Aasen, blocked 2-stage --- @defgroup hetrf_aa_2stage {he,sy}trf_aa_2stage: triangular factor @defgroup hetrs_aa_2stage {he,sy}trs_aa_2stage: triangular solve using factor @} @defgroup trsv_comp_grp Triangular computational routines (solve, cond, etc.) @{ @defgroup trsv_comp --- full --- @defgroup trcon trcon: condition number estimate @defgroup trtrs trtrs: triangular solve @defgroup latrs latrs: triangular solve with robust scaling @defgroup latrs3 latrs3: triangular solve with robust scaling, level 3 @defgroup trtri trtri: triangular inverse @defgroup trti2 trti2: triangular inverse, level 2 @defgroup trrfs trrfs: triangular iterative refinement @defgroup lauum lauum: triangular multiply: U^H U @defgroup lauu2 lauu2: triangular multiply: U^H U, level 2 @defgroup tpsv_comp --- packed --- @defgroup tpcon tpcon: condition number estimate @defgroup tptrs tptrs: triangular solve @defgroup latps latps: triangular solve with robust scaling @defgroup tptri tptri: triangular inverse @defgroup tprfs tprfs: triangular iterative refinement @defgroup tfsv_comp --- rectangular full packed (RFP) --- @defgroup tftri tftri: triangular inverse, RFP @defgroup tbsv_comp --- banded --- @defgroup tbcon tbcon: condition number estimate @defgroup tbtrs tbtrs: triangular solve @defgroup latbs latbs: triangular solve with scaling @defgroup tbrfs tbrfs: triangular iterative refinement @} @defgroup solve_aux_grp Auxiliary routines @{ @defgroup lacn2 lacn2: 1-norm estimate, e.g., || A^{-1} ||_1 in gecon @defgroup lacon lacon: 1-norm estimate, e.g., || A^{-1} ||_1 in gecon, old @defgroup la_lin_berr la_lin_berr: backward error @} @} @defgroup gels_top Least squares @{ @defgroup gels_driver_grp Standard least squares, min || Ax - b ||_2 @{ @defgroup gels gels: least squares using QR/LQ @defgroup gelst gelst: least squares using QR/LQ with T matrix @defgroup gelss gelss: least squares using SVD, QR iteration @defgroup gelsd gelsd: least squares using SVD, divide and conquer @defgroup gelsy gelsy: least squares using complete orthogonal factor @defgroup getsls getsls: least squares using tall-skinny QR/LQ @} @defgroup ggls_driver_grp Constrained least squares @{ @defgroup gglse gglse: equality-constrained least squares @defgroup ggglm ggglm: Gauss-Markov linear model @} @defgroup gels_aux_grp Auxiliary routines @{ @defgroup laic1 laic1: condition estimate, step in gelsy @defgroup lals0 lals0: back multiplying factors, step in gelsd @defgroup lalsa lalsa: SVD of coefficient matrix, step in gelsd @defgroup lalsd lalsd: uses SVD for least squares, step in gelsd @} @} @defgroup unitary_top Orthogonal/unitary factors (QR, CS, etc.) @{ @defgroup geqr_comp_grp QR @{ @defgroup geqr_comp1 --- flexible --- @defgroup geqr geqr: QR factor, flexible @defgroup gemqr gemqr: multiply by Q from geqr @defgroup geqr_comp2 --- classic --- @defgroup geqrf geqrf: QR factor @defgroup geqr2 geqr2: QR factor, level 2 @defgroup ungqr {un,or}gqr: generate explicit Q from geqrf @defgroup ung2r {un,or}g2r: generate explicit Q from geqrf, level 2 @defgroup unmqr {un,or}mqr: multiply by Q from geqrf @defgroup unm2r {un,or}m2r: multiply by Q from geqrf, level 2 @defgroup geqr_comp3 --- with T --- @defgroup geqrt geqrt: QR factor, with T @defgroup geqrt2 geqrt2: QR factor, with T, level 2 @defgroup geqrt3 geqrt3: QR factor, with T, recursive panel @defgroup gemqrt gemqrt: multiply by Q from geqrt @defgroup geqr_comp4 --- positive --- @defgroup geqrfp geqrfp: QR factor, diag( R ) ≥ 0 @defgroup geqr2p geqr2p: QR factor, diag( R ) ≥ 0, level 2 @} @defgroup geqpf_comp_grp QR with pivoting @{ @defgroup geqp3 geqp3: QR factor with pivoting, level 3 @defgroup laqp2 laqp2: step of geqp3 @defgroup laqps laqps: step of geqp3 @} @defgroup getsqr_comp_grp QR, tall-skinny @{ @defgroup latsqr latsqr: tall-skinny QR factor @defgroup ungtsqr {un,or}gtsqr: generate Q from latsqr @defgroup ungtsqr_row {un,or}gtsqr_row: generate Q from latsqr @defgroup larfb_gett larfb_gett: step in ungtsqr_row @defgroup lamtsqr lamtsqr: multiply by Q from latsqr @defgroup getsqrhrt getsqrhrt: tall-skinny QR factor, with Householder reconstruction @defgroup unhr_col {un,or}hr_col: Householder reconstruction @defgroup launhr_col_getrfnp la{un,or}hr_col_getrfnp: LU factor without pivoting @defgroup launhr_col_getrfnp2 la{un,or}hr_col_getrfnp2: LU factor without pivoting, level 2 @} @defgroup tpqr_comp_grp QR, triangular-pentagonal @{ @defgroup tpqrt tpqrt: QR factor @defgroup tpqrt2 tpqrt2: QR factor, level 2 @defgroup tpmqrt tpmqrt: applies Q @defgroup tprfb tprfb: applies Q (like larfb) @} @defgroup ggqr_comp_grp Generalized QR @{ @defgroup ggqrf ggqrf: Generalized QR factor @} @defgroup gelq_comp_grp LQ @{ @defgroup gelq_comp1 --- flexible --- @defgroup gelq gelq: LQ factor, flexible @defgroup gemlq gemlq: multiply by Q from gelq @defgroup gelq_comp2 --- classic --- @defgroup gelqf gelqf: LQ factor @defgroup gelq2 gelq2: LQ factor, level 2 @defgroup unglq {un,or}glq: generate explicit Q from gelqf @defgroup ungl2 {un,or}gl2: generate explicit Q, level 2, step in unglq @defgroup unmlq {un,or}mlq: multiply by Q from gelqf @defgroup unml2 {un,or}ml2: multiply by Q, level 2, step in unmlq @defgroup gelq_comp3 --- with T --- @defgroup gelqt gelqt: LQ factor, with T @defgroup gelqt3 gelqt3: LQ factor, with T, recursive @defgroup gemlqt gemlqt: multiply by Q from gelqt @} @defgroup geswlq_comp_grp LQ, short-wide @{ @defgroup laswlq laswlq: short-wide LQ factor @defgroup lamswlq lamswlq: multiply by Q from laswlq @} @defgroup tplq_comp_grp LQ, triangular-pentagonal @{ @defgroup tplqt tplqt: QR factor @defgroup tplqt2 tplqt2: QR factor, level 2 @defgroup tpmlqt tpmlqt: applies Q @} @defgroup geql_comp_grp QL @{ @defgroup geqlf geqlf: QL factor @defgroup geql2 geql2: QL factor, level 2 @defgroup ungql {un,or}gql: generate explicit Q from geqlf @defgroup unmql {un,or}mql: multiply by Q from geqlf @defgroup ung2l {un,or}g2l: step in ungql @defgroup unm2l {un,or}m2l: step in unmql @} @defgroup gerq_comp_grp RQ @{ @defgroup gerqf gerqf: RQ factor @defgroup gerq2 gerq2: RQ factor, level 2 @defgroup ungrq {un,or}grq: generate explicit Q from gerqf @defgroup unmrq {un,or}mrq: multiply by Q from gerqf @defgroup unmr2 {un,or}mr2: step in unmrq @defgroup ungr2 {un,or}gr2: step in ungrq @} @defgroup ggrq_comp_grp Generalized RQ @{ @defgroup ggrqf ggrqf: Generalized RQ factor @} @defgroup gerz_comp_grp RZ @{ @defgroup tzrzf tzrzf: RZ factor @defgroup latrz latrz: RZ factor step @defgroup unmrz {un,or}mrz: multiply by Z from tzrzf @defgroup unmr3 {un,or}mr3: step in unmrz @defgroup larz larz: apply reflector @defgroup larzb larzb: apply block reflector @defgroup larzt larzt: generate T matrix @} @defgroup gecs_comp_grp Cosine-Sine (CS) decomposition @{ @defgroup bbcsd bbcsd: ?? @defgroup uncsd {un,or}csd: ?? @defgroup uncsd2by1 {un,or}csd2by1: ?? @defgroup unbdb {un,or}bdb: bidiagonalize partitioned unitary matrix, step in uncsd @defgroup unbdb1 {un,or}bdb1: step in uncsd2by1 @defgroup unbdb2 {un,or}bdb2: step in uncsd2by1 @defgroup unbdb3 {un,or}bdb3: step in uncsd2by1 @defgroup unbdb4 {un,or}bdb4: step in uncsd2by1 @defgroup unbdb5 {un,or}bdb5: step in uncsd2by1 @defgroup unbdb6 {un,or}bdb6: step in uncsd2by1 @defgroup lapmr lapmr: permute rows @defgroup lapmt lapmt: permute cols @} @defgroup reflector_aux_grp Householder reflectors @{ @defgroup larf larf: apply Householder reflector @defgroup larfx larfx: apply Householder reflector, unrolled @defgroup larfy larfy: apply Householder reflector symmetrically (2-sided) @defgroup larfb larfb: apply block Householder reflector @defgroup larfg larfg: generate Householder reflector @defgroup larfgp larfgp: generate Householder reflector, beta ≥ 0 @defgroup larft larft: generate T matrix @} @defgroup rot_aux_grp Givens/Jacobi plane rotations @{ @defgroup lartg lartg: generate plane rotation, more accurate than BLAS rot @defgroup lartgp lartgp: generate plane rotation, more accurate than BLAS rot @defgroup lasr lasr: apply series of plane rotations @defgroup largv largv: generate vector of plane rotations @defgroup lartv lartv: apply vector of plane rotations to vectors @defgroup lar2v lar2v: apply vector of plane rotations to 2x2 matrices @defgroup lacrt lacrt: apply plane rotation (unused?) @} @} @defgroup geev_top Non-symmetric eigenvalues @{ @defgroup geev_driver_grp Standard eig driver, AV = VΛ @{ @defgroup geev geev: eig @defgroup geevx geevx: eig, expert @defgroup gees gees: Schur form @defgroup geesx geesx: Schur form, expert @} @defgroup ggev_driver_grp Generalized eig driver @{ @defgroup ggev3 ggev3: eig @defgroup ggev ggev: eig, unblocked @defgroup ggevx ggevx: eig, expert @defgroup gges3 gges3: Schur form @defgroup gges gges: Schur form, unblocked @defgroup ggesx ggesx: Schur form, expert @} @defgroup gedmd DMD driver, Dynamic Mode Decomposition @defgroup geev_comp_grp Eig computational routines @{ @defgroup gebal gebal: balance matrix @defgroup gehrd gehrd: reduction to Hessenberg @defgroup gehd2 gehd2: reduction to Hessenberg, level 2 @defgroup lahr2 lahr2: step in gehrd @defgroup unghr {un,or}ghr: generate Q from gehrd @defgroup unmhr {un,or}mhr: multiply by Q from gehrd @defgroup gebak gebak: back-transform eigvec @defgroup hseqr hseqr: Hessenberg eig, QR iteration @defgroup hsein hsein: Hessenberg inverse iteration for eigvec @defgroup trevc trevc: eigenvectors of triangular Schur form, old @defgroup trevc3 trevc3: eigenvectors of triangular Schur form, blocked @defgroup laln2 laln2: 1x1 or 2x2 solve, step in trevc @defgroup trsyl trsyl: Sylvester equation @defgroup trsyl3 trsyl3: Sylvester equation, level 3 @defgroup lasy2 lasy2: Sylvester equation @defgroup trsna trsna: eig condition numbers @defgroup laqtr laqtr: quasi-triangular solve @defgroup trexc trexc: reorder Schur form @defgroup trsen trsen: reorder Schur form @defgroup laexc laexc: reorder Schur form @defgroup lanv2 lanv2: 2x2 Schur factor @defgroup laqr_group --- hseqr auxiliary --- @defgroup laein laein: eigvec by Hessenberg inverse iteration @defgroup lahqr lahqr: eig of Hessenberg, step in hseqr @defgroup laqr0 laqr0: eig of Hessenberg, step in hseqr @defgroup laqr1 laqr1: step in hseqr @defgroup laqr2 laqr2: step in hseqr @defgroup laqr3 laqr3: step in hseqr @defgroup laqr4 laqr4: eig of Hessenberg, step in hseqr @defgroup laqr5 laqr5: step in hseqr @defgroup iparmq iparmq: set parameters for hseqr @defgroup laqz_group --- ggev3, gges3 auxiliary --- @defgroup laqz0 laqz0: step in ggev3, gges3 @defgroup laqz1 laqz1: step in ggev3, gges3 @defgroup laqz2 laqz2: step in ggev3, gges3 @defgroup laqz3 laqz3: step in ggev3, gges3 @defgroup laqz4 laqz4: step in ggev3, gges3 @} @defgroup ggev_comp_grp Generalized eig computational routines @{ @defgroup ggbal ggbal: balance matrix @defgroup gghrd gghrd: reduction to Hessenberg @defgroup gghd3 gghd3: reduction to Hessenberg, level 3 @defgroup hgeqz hgeqz: generalized Hessenberg eig @defgroup ggbak ggbak: back-transform eigvec @defgroup tgsen tgsen: reorder generalized Schur form @defgroup tgsna tgsna: reciprocal cond est @defgroup tgsyl tgsyl: Sylvester equation @defgroup tgsy2 tgsy2: Sylvester equation panel (?) @defgroup unm22 {un,or}m22: multiply by banded Q, step in gghd3 @defgroup lagv2 lagv2: 2x2 generalized Schur factor @defgroup tgevc tgevc: eigvec of pair of matrices @defgroup tgexc tgexc: reorder generalized Schur form @defgroup tgex2 tgex2: reorder generalized Schur form @} @} @defgroup heev_top Hermitian/symmetric eigenvalues @{ @defgroup heev_driver_grp Standard eig driver, AV = VΛ @{ @defgroup heev_driver --- full --- @defgroup heev {he,sy}ev: eig, QR iteration @defgroup heevd {he,sy}evd: eig, divide and conquer @defgroup heevr {he,sy}evr: eig, MRRR @defgroup heevx {he,sy}evx: eig, bisection @defgroup heev_driver2 --- full, 2-stage --- @defgroup heev_2stage {he,sy}ev_2stage: eig, QR iteration @defgroup heevd_2stage {he,sy}evd_2stage: eig, divide and conquer @defgroup heevr_2stage {he,sy}evr_2stage: eig, MRRR @defgroup heevx_2stage {he,sy}evx_2stage: eig, bisection @defgroup hpev_driver --- packed --- @defgroup hpev {hp,sp}ev: eig, QR iteration @defgroup hpevd {hp,sp}evd: eig, divide and conquer @defgroup hpevx {hp,sp}evx: eig, bisection @defgroup hbev_driver --- banded --- @defgroup hbev {hb,sb}ev: eig, QR iteration @defgroup hbevd {hb,sb}evd: eig, divide and conquer @defgroup hbevx {hb,sb}evx: eig, bisection @defgroup hbev_driver2 --- banded, 2nd-stage --- @defgroup hbev_2stage {hb,sb}ev_2stage: eig, QR iteration @defgroup hbevd_2stage {hb,sb}evd_2stage: eig, divide and conquer @defgroup hbevx_2stage {hb,sb}evx_2stage: eig, bisection @defgroup stev_driver --- tridiagonal --- @defgroup stev stev: eig, QR iteration @defgroup stevd stevd: eig, divide and conquer @defgroup stevr stevr: eig, MRRR @defgroup stevx stevx: eig, bisection @defgroup pteqr pteqr: eig, positive definite tridiagonal @defgroup stebz stebz: eig, Kahan @defgroup sterf sterf: eig, QR iteration @defgroup stedc stedc: eig, divide and conquer @defgroup stegr stegr: eig, bisection, see stemr @defgroup stein stein: eig, inverse iteration @defgroup stemr stemr: eig, relatively robust representation (RRR) @defgroup steqr steqr: eig, QR iteration @} @defgroup hegv_driver_grp Generalized eig driver, AV = BVΛ, etc. @{ @defgroup hegv_driver --- full --- @defgroup hegv {he,sy}gv: eig, QR iteration @defgroup hegv_2stage {he,sy}gv_2stage: eig, QR iteration, 2-stage @defgroup hegvd {he,sy}gvd: eig, divide and conquer @defgroup hegvx {he,sy}gvx: eig, bisection @defgroup hpgv_driver --- packed --- @defgroup hpgv {hp,sp}gv: eig, QR iteration @defgroup hpgvd {hp,sp}gvd: eig, divide and conquer @defgroup hpgvx {hp,sp}gvx: eig, bisection @defgroup hbgv_driver --- banded --- @defgroup hbgv {hb,sb}gv: eig, QR iteration @defgroup hbgvd {hb,sb}gvd: eig, divide and conquer @defgroup hbgvx {hb,sb}gvx: eig, bisection @} @defgroup heev_comp_grp Eig computational routines @{ @defgroup heev_comp --- full --- @defgroup disna disna: eig condition numbers @defgroup hetrd {he,sy}trd: reduction to tridiagonal @defgroup hetd2 {he,sy}td2: reduction to tridiagonal, level 2 @defgroup latrd latrd: step in hetrd @defgroup ungtr {un,or}gtr: generate Q from hetrd @defgroup unmtr {un,or}mtr: multiply by Q from hetrd @defgroup hetrd_2stage {he,sy}trd_2stage: reduction to tridiagonal, 2-stage @defgroup hetrd_he2hb {he,sy}trd_he2hb: full to band (1st stage) @defgroup hetrd_hb2st {he,sy}trd_hb2st: band to tridiagonal (2nd stage) @defgroup hb2st_kernels {hb,sb}2st_kernels: band to tridiagonal (2nd stage) @defgroup lae2 lae2: 2x2 eig, step in steqr, stemr @defgroup laesy laesy: 2x2 eig @defgroup laev2 laev2: 2x2 eig @defgroup lagtf lagtf: LU factor of (T - λI) @defgroup lagts lagts: LU solve of (T - λI) x = y @defgroup hpev_comp --- packed --- @defgroup hptrd {hp,sp}trd: reduction to tridiagonal @defgroup upgtr {up,op}gtr: generate Q from hetrd @defgroup upmtr {up,op}mtr: multiply by Q from hptrd @defgroup hbev_comp --- banded --- @defgroup hbtrd {hb,sb}trd: reduction to tridiagonal @} @defgroup hegv_comp_grp Generalized eig computational routines @{ @defgroup hegst {he,sy}gst: reduction to standard form @defgroup hegs2 {he,sy}gs2: reduction to standard form, level 2 @defgroup hpgst {hp,sp}gst: reduction to standard form, packed @defgroup hbgst {hb,sb}gst: reduction to standard form, banded @defgroup pbstf pbstf: split Cholesky factor, use with hbgst @defgroup lag2 lag2: 2x2 eig @} @defgroup stev_comp_grp tridiag bisection routines @{ @defgroup laebz laebz: counts eigvals <= value @defgroup laneg laneg: Sturm count @} @defgroup laed_comp_grp tridiag divide and conquer (D&C) routines @{ @defgroup laed0 laed0: D&C step: top level solver @defgroup laed1 laed1: D&C step: merge subproblems @defgroup laed2 laed2: D&C step: deflation @defgroup laed3 laed3: D&C step: secular equation @defgroup laed4 laed4: D&C step: secular equation nonlinear solver @defgroup laed5 laed5: D&C step: secular equation, 2x2 @defgroup laed6 laed6: D&C step: secular equation Newton step @defgroup lamrg lamrg: permutation to merge 2 sorted lists @defgroup laed_comp2 --- eig value only or update Q --- @defgroup laed7 laed7: D&C step: merge subproblems @defgroup laed8 laed8: D&C step: deflation @defgroup laed9 laed9: D&C step: secular equation @defgroup laeda laeda: D&C step: z vector @} @defgroup larr_comp_grp tridiag RRR routines @{ @defgroup larra larra: step in stemr @defgroup larrb larrb: step in stemr @defgroup larrc larrc: step in stemr @defgroup larrd larrd: step in stemr, tridiag eig @defgroup larre larre: step in stemr @defgroup larrf larrf: step in stemr, find relative robust representation (RRR) @defgroup larrj larrj: step in stemr, refine eigval estimates @defgroup larrk larrk: step in stemr, compute one eigval @defgroup larrr larrr: step in stemr, test to do expensive tridiag eig algorithm @defgroup larrv larrv: eig tridiagonal, step in stemr & stegr @defgroup lar1v lar1v: step in larrv, hence stemr & stegr @} @} @defgroup svd_top Singular Value Decomposition (SVD) @{ @defgroup svd_driver_grp Standard SVD driver, A = UΣV^H @{ @defgroup gesvd_driver --- full --- @defgroup gesvd gesvd: SVD, QR iteration @defgroup gesvdq gesvdq: SVD, QR with pivoting @defgroup gesdd gesdd: SVD, divide and conquer @defgroup gesvdx gesvdx: SVD, bisection @defgroup gejsv gejsv: SVD, Jacobi, high-level @defgroup gesvj gesvj: SVD, Jacobi, low-level @defgroup bdsvd_driver --- bidiagonal --- @defgroup bdsqr bdsqr: bidiagonal SVD, QR iteration (dqds) @defgroup bdsdc bdsdc: bidiagonal SVD, divide and conquer @defgroup bdsvdx bdsvdx: bidiagonal SVD, bisection @} @defgroup ggsvd_driver_grp Generalized SVD driver @{ @defgroup ggsvd3 ggsvd3: SVD, QR iteration @} @defgroup gesvd_comp_grp SVD computational routines @{ @defgroup gebrd gebrd: reduction to bidiagonal @defgroup gebd2 gebd2: reduction to bidiagonal, level 2 @defgroup labrd labrd: step in gebrd @defgroup gbbrd gbbrd: band to bidiagonal @defgroup ungbr {un,or}gbr: generate Q, P from gebrd @defgroup unmbr {un,or}mbr: multiply by Q, P from gebrd @defgroup gesvd_aux --- auxiliary routines --- @defgroup gsvj0 gsvj0: step in gesvj @defgroup gsvj1 gsvj1: step in gesvj @defgroup las2 las2: 2x2 triangular SVD @defgroup lasv2 lasv2: 2x2 triangular SVD @defgroup lartgs lartgs: generate plane rotation for bidiag SVD @} @defgroup ggsvd_comp_grp Generalized SVD computational routines @{ @defgroup ggsvp3 ggsvp3: step in ggsvd @defgroup tgsja tgsja: generalized SVD of trapezoidal matrices, step in ggsvd3 @defgroup lags2 lags2: 2x2 orthogonal factor, step in tgsja @defgroup lapll lapll: linear dependence of 2 vectors @} @defgroup lasq_comp_grp bidiag QR iteration routines @{ @defgroup lasq1 lasq1: dqds step @defgroup lasq2 lasq2: dqds step @defgroup lasq3 lasq3: dqds step @defgroup lasq4 lasq4: dqds step @defgroup lasq5 lasq5: dqds step @defgroup lasq6 lasq6: dqds step @} @defgroup lasd_comp_grp bidiag D&C routines @{ @defgroup lasd0 lasd0: D&C step: top level solver @defgroup lasdt lasdt: D&C step: tree @defgroup lasd1 lasd1: D&C step: merge subproblems @defgroup lasd2 lasd2: D&C step: deflation @defgroup lasd3 lasd3: D&C step: secular equation @defgroup lasd4 lasd4: D&C step: secular equation nonlinear solver @defgroup lasd5 lasd5: D&C step: secular equation, 2x2 @defgroup lasdq lasdq: D&C step: leaf using bdsqr @defgroup lasd_comp2 --- singular values only or factored form --- @defgroup lasda lasda: D&C step: top level solver @defgroup lasd6 lasd6: D&C step: merge subproblems @defgroup lasd7 lasd7: D&C step: deflation @defgroup lasd8 lasd8: D&C step: secular equation @} @} @defgroup blas_like_top BLAS-like @{ @defgroup set_grp Initialize, copy, convert @{ @defgroup laset laset: set matrix @defgroup larnv larnv: random vector @defgroup laruv laruv: random uniform vector @defgroup lacpy lacpy: copy matrix @defgroup lacp2 lacp2: general matrix, convert real to complex @defgroup _lag2_ _lag2_: general matrix, convert double <=> single @defgroup _lat2_ _lat2_: triangular matrix, convert double <=> single @defgroup tfttp tfttp: triangular matrix, RFP (tf) to packed (tp) @defgroup tfttr tfttr: triangular matrix, RFP (tf) to full (tr) @defgroup tpttf tpttf: triangular matrix, packed (tp) to RFP (tf) @defgroup tpttr tpttr: triangular matrix, packed (tp) to full (tr) @defgroup trttf trttf: triangular matrix, full (tr) to RFP (tf) @defgroup trttp trttp: triangular matrix, full (tr) to packed (tp) @} @defgroup norm_grp Matrix norm @{ @defgroup lange lange: general matrix @defgroup langb langb: general matrix, banded @defgroup langt langt: general matrix, tridiagonal @defgroup lanhs lanhs: Hessenberg @defgroup lanhe lan{he,sy}: Hermitian/symmetric matrix @defgroup lanhf lan{hf,sf}: Hermitian/symmetric matrix, RFP @defgroup lanhp lan{hp,sp}: Hermitian/symmetric matrix, packed @defgroup lanhb lan{hb,sb}: Hermitian/symmetric matrix, banded @defgroup lanht lan{ht,st}: Hermitian/symmetric matrix, tridiagonal @defgroup lantr lantr: triangular matrix @defgroup lantp lantp: triangular matrix, packed @defgroup lantb lantb: triangular matrix, banded @} @defgroup blas0_like_grp Scalar operations @{ @defgroup isnan isnan: test for NaN @defgroup laisnan laisnan: test for NaN, unoptimized @defgroup ladiv ladiv: complex divide @defgroup lapy2 lapy2: robust sqrt( x^2 + y^2 ) @defgroup lapy3 lapy3: robust sqrt( x^2 + y^2 + z^2 ) @defgroup larmm larmm: scale factor to avoid overflow, step in latrs @} @defgroup blas1_like_grp Level 1 BLAS-like vector ops @{ @defgroup lacgv lacgv: conjugate vector @defgroup lasrt lasrt: sort vector @defgroup lassq lassq: sum-of-squares, avoiding over/underflow @defgroup rscl rscl: scale vector by reciprocal @} @defgroup blas2_like_grp Level 2 BLAS-like matrix-vector ops @{ @defgroup ilalc ilalc: find non-zero col @defgroup ilalr ilalr: find non-zero row @defgroup lascl lascl: scale matrix @defgroup la_geamv la_geamv: matrix-vector multiply |A| * |x|, general @defgroup la_gbamv la_gbamv: matrix-vector multiply |A| * |x|, general banded @defgroup la_heamv la_heamv: matrix-vector multiply |A| * |x|, Hermitian/symmetric @defgroup lascl2 lascl2: diagonal scale matrix, A = D A @defgroup larscl2 larscl2: reciprocal diagonal scale matrix, A = D^{-1} A @defgroup la_wwaddw la_wwaddw: add to double-double or single-single vector @} @defgroup blas3_like_grp Level 3 BLAS-like matrix-matrix ops @{ @defgroup lagtm lagtm: tridiagonal matrix-matrix multiply @defgroup lacrm lacrm: complex * real matrix-matrix multiply @defgroup larcm larcm: real * complex matrix-matrix multiply @defgroup hfrk hfrk: Hermitian rank-k update, RFP format @defgroup tfsm tfsm: triangular-matrix solve, RFP format @} @} @defgroup aux_top Auxiliary routines @{ @defgroup aux_grp Other auxiliary routines @{ @defgroup lsame lsame: string comparison @defgroup lsamen lsamen: string comparison @defgroup roundup_lwork roundup_lwork: fix rounding integer to float @defgroup second second: wall clock timer @} @defgroup params_grp Parameters @{ @defgroup lamch lamch: machine parameters @defgroup lamc1 lamc1: ?? @defgroup lamc2 lamc2: ?? @defgroup lamc3 lamc3: ?? @defgroup lamc4 lamc4: ?? @defgroup lamc5 lamc5: ?? @defgroup labad labad: over/underflow on obsolete pre-IEEE machines @defgroup ilaver ilaver: LAPACK version @defgroup ilaenv ilaenv: tuning parameters @defgroup ilaenv2stage ilaenv2stage: tuning parameters for 2-stage eig @defgroup iparam2stage iparam2stage: sets parameters for 2-stage eig @defgroup ieeeck ieeeck: verify inf and NaN are safe @defgroup la_constants la_constants: Fortran 95 module of constants @defgroup blast_aux --- BLAST constants --- @defgroup iladiag iladiag: diag string to BLAST const @defgroup ilaprec ilaprec: precision string to BLAST const @defgroup ilatrans ilatrans: trans string to BLAST const @defgroup ilauplo ilauplo: uplo string to BLAST const @defgroup la_transtype la_transtype: BLAST const to string @} @defgroup xerbla_grp Error reporting @{ @defgroup xerbla xerbla: error reporting @defgroup xerbla_array xerbla_array: error reporting, callable from C @} @} @} @defgroup blas_top BLAS BLAS are defined by three papers: Basic linear algebra subprograms for {FORTRAN} usage, Lawson et al, 1979. An extended set of {FORTRAN} basic linear algebra subprograms, Dongarra et al, 1988. A set of level 3 basic linear algebra subprograms, Dongarra et al, 1990. Some BLAS-like routines (e.g., csymv, crot, csum1, icmax1) exist in LAPACK rather than the classic BLAS. These were extended by the Extra Precision BLAS (XBLAS, not documented here) https://www.netlib.org/xblas/ @{ @defgroup scalar_grp Scalar operations @{ @defgroup abs1 abs1: | real( x ) | + | imag( x ) | @} @defgroup blas1_grp Level 1 BLAS: vector ops @{ @defgroup asum asum: sum | real( x_i ) | + | imag( x_i ) | @defgroup sum1 sum1: sum | x_i | (in LAPACK) @defgroup axpy axpy: y = ax + y @defgroup copy copy: y = x @defgroup dot dot: x^H x and x^T x @defgroup iamax iamax: argmax_i | real( x_i ) | + | imag( x_i ) | @defgroup imax1 imax1: argmax_i | x_i | (in LAPACK) @defgroup nrm2 nrm2: || x ||_2 @defgroup scal scal: x = alpha x @defgroup swap swap: x <=> y @defgroup rot_comp --- Givens/Jacobi plane rotations --- @defgroup rot rot: apply plane rotation ([cz]rot in LAPACK) @defgroup rotg rotg: generate plane rotation (cf. lartg) @defgroup rotm rotm: apply modified (fast) plane rotation @defgroup rotmg rotmg: generate modified (fast) plane rotation @} @defgroup blas2_grp Level 2 BLAS: matrix-vector ops @{ @defgroup blas2_full --- full --- @defgroup gemv gemv: general matrix-vector multiply @defgroup ger ger: general matrix rank-1 update @defgroup hemv {he,sy}mv: Hermitian/symmetric matrix-vector multiply ([cz]symv in LAPACK) @defgroup her {he,sy}r: Hermitian/symmetric rank-1 update @defgroup her2 {he,sy}r2: Hermitian/symmetric rank-2 update @defgroup trmv trmv: triangular matrix-vector multiply @defgroup trsv trsv: triangular matrix-vector solve @defgroup blas2_packed --- packed --- @defgroup hpmv {hp,sp}mv: Hermitian/symmetric matrix-vector multiply @defgroup hpr {hp,sp}r: Hermitian/symmetric rank-1 update @defgroup hpr2 {hp,sp}r2: Hermitian/symmetric rank-2 update @defgroup tpmv tpmv: triangular matrix-vector multiply @defgroup tpsv tpsv: triangular matrix-vector solve @defgroup blas2_banded --- banded --- @defgroup gbmv gbmv: general matrix-vector multiply @defgroup hbmv {hb,sb}mv: Hermitian/symmetric matrix-vector multiply @defgroup tbmv tbmv: triangular matrix-vector multiply @defgroup tbsv tbsv: triangular matrix-vector solve @} @defgroup blas3_grp Level 3 BLAS: matrix-matrix ops @{ @defgroup gemm gemm: general matrix-matrix multiply @defgroup hemm {he,sy}mm: Hermitian/symmetric matrix-matrix multiply @defgroup herk {he,sy}rk: Hermitian/symmetric rank-k update @defgroup her2k {he,sy}r2k: Hermitian/symmetric rank-2k update @defgroup trmm trmm: triangular matrix-matrix multiply @defgroup trsm trsm: triangular matrix-matrix solve @} @} **/