lapacke_utils.h(3)

📦 version 3.9.0, in centos-stream 9

💅 lapacke_utils.h(3) — the LAPACK one, bestie

okay so this is lapacke_utils.h, straight out of the LAPACK manual, section 3. it's a header full of tiny helper macros that the LAPACKE world leans on, and honestly? it's giving "small but iconic." 🎀

✨ NAME ✨

lapacke_utils.h — that's it, that's the name, no cap. it's a header file, and this page is its whole personality. 🦋

🌸 SYNOPSIS 🌸

you pull it in like this, literally just this one line:

#include 'lapacke.h'

(yeah, the include line is spelled exactly like that on this page — keep it as-is, bestie, i don't make the rules 💅)

🎀 Macros 🎀

okay so here's the whole squad of macros. every single one, in order, exactly how they're written. these are the little one-liners doing the actual work 🫶

#define ABS(x) (((x) < 0) ? -(x) : (x)) — absolute value, but make it a macro. if x is less than zero it flips the sign, otherwise it leaves x alone. classic. ⭐
#define MAX(x, y) (((x) > (y)) ? (x) : (y)) — the bigger one of the two. x wins if it beats y, otherwise y takes it. 👑
#define MIN(x, y) (((x) < (y)) ? (x) : (y)) — the smaller one. same energy, opposite direction. 🦋
#define MAX3(x, y, z) (((x) > MAX(y,z)) ? (x) : MAX(y,z)) — three-way max, built on top of MAX. so if x beats the winner of y vs z, x slays; otherwise the MAX(y,z) champ takes it. 🔥
#define MIN3(x, y, z) (((x) < MIN(y,z)) ? (x) : MIN(y,z)) — three-way min, same deal but with MIN. 🌸
#define IS_S_NONZERO(x) ( (x) < 0 || (x) > 0 ) — single-precision "is this thing not zero?" check. true if x is below zero or above zero. 🧚
#define IS_D_NONZERO(x) ( (x) < 0 || (x) > 0 ) — double-precision version of the exact same check. same body, different letter. 💜
#define IS_C_NONZERO(x) — the single-complex "is it nonzero?" check. heads up: this page doesn't show a body for it, so that's all we're getting here 🙈
#define IS_Z_NONZERO(x) — the double-complex "is it nonzero?" check, and same situation: no body listed on this page. 💀
#define LAPACK_SISNAN(x) ( x != x ) — single-precision NaN detector, and the trick is genuinely iconic: NaN is the one thing that isn't equal to itself, so x != x catches it. 😭
#define LAPACK_DISNAN(x) ( x != x ) — double-precision NaN detector, same trick, same x != x. ✨
#define LAPACK_CISNAN(x) — single-complex NaN check, and once again this page doesn't spell out the body, so no invented details from me 🎀
#define LAPACK_ZISNAN(x) — double-complex NaN check, body not shown here either. 🦋

lowkey important: ABS, MAX, MIN, MAX3, MIN3 and the IS_*/LAPACK_*ISNAN friends are all macros, so they're pasted in as text, not called like functions — that's just what a #define is, no extra lore needed 💅

more parts are coming, so don't go anywhere bestie 🫶

✨ Functions ✨

Okay bestie, this is the part where the header blesses you with actual callable functions — and there are so many of them. Like, seventy-something. I'm not exaggerating, I counted. They mostly come in four flavours (c, d, s, z) and they're all void except the two that actually tell you something. Let's go 🫶

🎀 the little helpers

LAPACKE_xerbla — the error-reporting bestie. You hand it a routine name and an info code, that's it, that's the whole vibe.

void LAPACKE_xerbla (const char *name, lapack_int info)

LAPACKE_lsame — compares two chars ca and cb and hands you back a lapack_logical. The l is doing a LOT of work in that name, iykyk.

lapack_logical LAPACKE_lsame (char ca, char cb)

💜 single precision complex — the `c…` squad

LAPACKE_cgb_trans — the general band one: m, n, kl, ku, reads from in with ldin, writes to out with ldout.

void LAPACKE_cgb_trans (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_cge_trans — general matrix energy. m, n, in/ldin in, out/ldout out ✨

void LAPACKE_cge_trans (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_cgg_trans — the gg variant, same m/n/ldin/ldout situation.

void LAPACKE_cgg_trans (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_chb_trans — takes a uplo, an n, and a bandwidth kd.

void LAPACKE_chb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_che_trans — uplo + n, no kd here, she's simpler than her banded sister 💅

void LAPACKE_che_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_chp_trans — packed, so no ldin/ldout at all. Just in and out, living their best lives.

void LAPACKE_chp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

LAPACKE_chs_trans — matrix_layout, n, in/ldin, out/ldout. No uplo, no notes.

void LAPACKE_chs_trans (int matrix_layout, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_cpb_trans — positive-definite and banded, so she gets uplo AND kd. Main character.

void LAPACKE_cpb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_cpf_trans — packed and rectangular-ish, so you get transr and uplo, and no leading dimensions. Iconic.

void LAPACKE_cpf_trans (int matrix_layout, char transr, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

LAPACKE_cpo_trans — uplo, n, in/ldin, out/ldout.

void LAPACKE_cpo_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_cpp_trans — packed, uplo, n, in, out. Clean, minimal, obsessed.

void LAPACKE_cpp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

LAPACKE_csp_trans — same packed uplo/n/in/out shape as above, different sp energy.

void LAPACKE_csp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

LAPACKE_csy_trans — uplo, n, and both leading dimensions because she is not packed, bestie.

void LAPACKE_csy_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_ctb_trans — triangular banded: uplo, diag, n, kd. Four arguments of pure chaos 🦋

void LAPACKE_ctb_trans (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

LAPACKE_ctf_trans — packed triangular, so transr, uplo, diag, n, and just the two pointers.

void LAPACKE_ctf_trans (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

LAPACKE_ctp_trans — packed triangular, no transr, no leading dimensions.

void LAPACKE_ctp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_complex_float *out)

LAPACKE_ctr_trans — the full triangular treatment: uplo, diag, n, in/ldin, out/ldout. Slay.

void LAPACKE_ctr_trans (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *in, lapack_int ldin, lapack_complex_float *out, lapack_int ldout)

🌸 double precision — the `d…` squad

LAPACKE_dgb_trans — general band, double. m, n, kl, ku, in/ldin, out/ldout — the full set, no cap.

void LAPACKE_dgb_trans (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dge_trans — the classic. m, n, double pointers, done.

void LAPACKE_dge_trans (int matrix_layout, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dgg_trans — same shape as dge, gg branding.

void LAPACKE_dgg_trans (int matrix_layout, lapack_int m, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dhs_trans — just matrix_layout, n, and the four array-ish things. Short and sweet 🍓

void LAPACKE_dhs_trans (int matrix_layout, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dpb_trans — banded + uplo + kd + both leading dims.

void LAPACKE_dpb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dpf_trans — packed, transr, uplo, n, and no leading dimensions at all.

void LAPACKE_dpf_trans (int matrix_layout, char transr, char uplo, lapack_int n, const double *in, double *out)

LAPACKE_dpo_trans — uplo, n, in/ldin, out/ldout.

void LAPACKE_dpo_trans (int matrix_layout, char uplo, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dpp_trans — packed uplo/n/in/out, four arguments and a dream.

void LAPACKE_dpp_trans (int matrix_layout, char uplo, lapack_int n, const double *in, double *out)

LAPACKE_dsb_trans — symmetric banded: uplo, n, kd, both leading dimensions.

void LAPACKE_dsb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dsp_trans — symmetric packed, uplo, n, in, out.

void LAPACKE_dsp_trans (int matrix_layout, char uplo, lapack_int n, const double *in, double *out)

LAPACKE_dsy_trans — symmetric, unpacked, leading dimensions included ✨

void LAPACKE_dsy_trans (int matrix_layout, char uplo, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dtb_trans — triangular banded: uplo, diag, n, kd, dims, dims.

void LAPACKE_dtb_trans (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const double *in, lapack_int ldin, double *out, lapack_int ldout)

LAPACKE_dtf_trans — packed triangular with transr AND uplo AND diag. She's booked and busy 💀

void LAPACKE_dtf_trans (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const double *in, double *out)

LAPACKE_dtp_trans — packed triangular, uplo, diag, n, in, out.

void LAPACKE_dtp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const double *in, double *out)

LAPACKE_dtr_trans — triangular, unpacked, uplo, diag, n, in/ldin, out/ldout.

void LAPACKE_dtr_trans (int matrix_layout, char uplo, char diag, lapack_int n, const double *in, lapack_int ldin, double *out, lapack_int ldout)

🦋 single precision — the `s…` squad

LAPACKE_sgb_trans — general band, float edition. m, n, kl, ku, both dims 🎀

void LAPACKE_sgb_trans (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_sge_trans — the float general matrix one. You know her, you love her.

void LAPACKE_sge_trans (int matrix_layout, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_sgg_trans — gg but float, same m/n/ldin/ldout deal.

void LAPACKE_sgg_trans (int matrix_layout, lapack_int m, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_shs_trans — n and the four array params. No uplo in sight, that's her vibe.

void LAPACKE_shs_trans (int matrix_layout, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_spb_trans — banded, uplo, kd, both leading dimensions. Full house.

void LAPACKE_spb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_spf_trans — packed, transr, uplo, n, in, out. Periodt.

void LAPACKE_spf_trans (int matrix_layout, char transr, char uplo, lapack_int n, const float *in, float *out)

LAPACKE_spo_trans — uplo, n, in/ldin, out/ldout.

void LAPACKE_spo_trans (int matrix_layout, char uplo, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_spp_trans — packed, uplo, n, in, out. Zero leading dimensions, zero problems.

void LAPACKE_spp_trans (int matrix_layout, char uplo, lapack_int n, const float *in, float *out)

LAPACKE_ssb_trans — symmetric banded, uplo, n, kd, plus both dims.

void LAPACKE_ssb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_ssp_trans — symmetric packed, uplo, n, in, out.

void LAPACKE_ssp_trans (int matrix_layout, char uplo, lapack_int n, const float *in, float *out)

LAPACKE_ssy_trans — symmetric and unpacked, so the leading dimensions are back 💅

void LAPACKE_ssy_trans (int matrix_layout, char uplo, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_stb_trans — triangular banded: uplo, diag, n, kd, dims, dims.

void LAPACKE_stb_trans (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const float *in, lapack_int ldin, float *out, lapack_int ldout)

LAPACKE_stf_trans — packed triangular with all three char flags: transr, uplo, diag. She has range 🌈

void LAPACKE_stf_trans (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const float *in, float *out)

LAPACKE_stp_trans — packed triangular, uplo, diag, n, in, out.

void LAPACKE_stp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const float *in, float *out)

LAPACKE_str_trans — triangular, unpacked, uplo, diag, n, in/ldin, out/ldout. Gorgeous.

void LAPACKE_str_trans (int matrix_layout, char uplo, char diag, lapack_int n, const float *in, lapack_int ldin, float *out, lapack_int ldout)

👑 double precision complex — the `z…` squad

LAPACKE_zgb_trans — general band, lapack_complex_double edition. m, n, kl, ku, both dims.

void LAPACKE_zgb_trans (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zge_trans — the big one. General, double complex, m × n, both leading dims 🌟

void LAPACKE_zge_trans (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zgg_trans — gg, double complex, same shape as zge.

void LAPACKE_zgg_trans (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zhb_trans — banded, uplo, n, kd, plus the two leading dimensions.

void LAPACKE_zhb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zhe_trans — uplo, n, no kd, both dims.

void LAPACKE_zhe_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zhp_trans — packed, so just uplo, n, in, out. Minimalist queen.

void LAPACKE_zhp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

LAPACKE_zhs_trans — matrix_layout, n, and the four array params, no uplo.

void LAPACKE_zhs_trans (int matrix_layout, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zpb_trans — banded + uplo + kd + both dims. The full entourage.

void LAPACKE_zpb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zpf_trans — packed, transr, uplo, n, in, out. Two chars and a dream 💜

void LAPACKE_zpf_trans (int matrix_layout, char transr, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

LAPACKE_zpo_trans — uplo, n, in/ldin, out/ldout.

void LAPACKE_zpo_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_zpp_trans — packed uplo/n/in/out, enjoy ✨

void LAPACKE_zpp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

LAPACKE_zsp_trans — symmetric packed, same four-argument shape.

void LAPACKE_zsp_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

LAPACKE_zsy_trans — symmetric unpacked, so the leading dimensions make their comeback 🎀

void LAPACKE_zsy_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_ztb_trans — triangular banded: uplo, diag, n, kd, dims, dims.

void LAPACKE_ztb_trans (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

LAPACKE_ztf_trans — packed triangular, all three char params: transr, uplo, diag.

void LAPACKE_ztf_trans (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

LAPACKE_ztp_trans — packed triangular, uplo, diag, n, in, out.

void LAPACKE_ztp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_complex_double *out)

LAPACKE_ztr_trans — triangular, unpacked, full param list. Final boss of the translators 🔥

void LAPACKE_ztr_trans (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *in, lapack_int ldin, lapack_complex_double *out, lapack_int ldout)

🧚 the `nancheck` crew

These ones actually return something — a lapack_logical — so they're the ones with opinions. First the flat vector ones, n elements, stride incx:

LAPACKE_c_nancheck — complex float vector, n elements, stride incx.

lapack_logical LAPACKE_c_nancheck (lapack_int n, const lapack_complex_float *x, lapack_int incx)

LAPACKE_d_nancheck — double vector, n, x, incx.

lapack_logical LAPACKE_d_nancheck (lapack_int n, const double *x, lapack_int incx)

LAPACKE_s_nancheck — float vector, n, x, incx.

lapack_logical LAPACKE_s_nancheck (lapack_int n, const float *x, lapack_int incx)

LAPACKE_z_nancheck — complex double vector, n, x, incx.

lapack_logical LAPACKE_z_nancheck (lapack_int n, const lapack_complex_double *x, lapack_int incx)

And then the matrix-flavoured checks, which take a matrix_layout and a leading dimension like the fancy translators do:

LAPACKE_cgb_nancheck — band storage check: matrix_layout, m, n, kl, ku, ab, ldab.

lapack_logical LAPACKE_cgb_nancheck (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *ab, lapack_int ldab)

LAPACKE_cge_nancheck — general matrix check: matrix_layout, m, n, a, lda.

lapack_logical LAPACKE_cge_nancheck (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)

LAPACKE_cgg_nancheck — gg version, same matrix_layout, m, n, a, lda situation.

lapack_logical LAPACKE_cgg_nancheck (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_float *a, lapack_int lda)

okay that's the function list, bestie — but we are not done, there's more page coming, don't close the tab 💖

okay so this is the rest of the function lineup — and I mean all of them, bestie, we are not skipping a single one 💅. Every single one of these hands back a lapack_logical, so it's a straight yes-or-no vibe.

First up, the c crew — lapack_complex_float everything, complex-float energy only 💜:

lapack_logical LAPACKE_cgt_nancheck (lapack_int n, const lapack_complex_float *dl, const lapack_complex_float *d, const lapack_complex_float *du) — the gt one takes n plus the three diagonals dl, d, du, and no matrix_layout because tridiagonal said "I'm built different" 🦋
lapack_logical LAPACKE_chb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *ab, lapack_int ldab) — banded hb behavior: matrix_layout, uplo, n, kd, the band storage ab, and ldab 🎀
lapack_logical LAPACKE_che_nancheck (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *a, lapack_int lda) — he in full storage, so it's the classic uplo / n / a / lda quartet ✨
lapack_logical LAPACKE_chp_nancheck (lapack_int n, const lapack_complex_float *ap) — packed hp, just n and ap, no lda invited to the party 🌸
lapack_logical LAPACKE_chs_nancheck (int matrix_layout, lapack_int n, const lapack_complex_float *a, lapack_int lda) — the hs cutie, rolling with matrix_layout, n, a, lda 💜
lapack_logical LAPACKE_cpb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_float *ab, lapack_int ldab) — banded pb, same guest list as hb: layout, uplo, n, kd, ab, ldab 🫶
lapack_logical LAPACKE_cpf_nancheck (lapack_int n, const lapack_complex_float *a) — pf keeps it light: n plus a, that's literally it 🎀
lapack_logical LAPACKE_cpo_nancheck (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *a, lapack_int lda) — po in full storage, doing the uplo/n/a/lda thing 🔥
lapack_logical LAPACKE_cpp_nancheck (lapack_int n, const lapack_complex_float *ap) — packed pp, so n and ap and nothing else 🌈
lapack_logical LAPACKE_cpt_nancheck (lapack_int n, const float *d, const lapack_complex_float *e) — okay look closely at pt 👀, d is a plain float but e is lapack_complex_float, do not mix them up 😭
lapack_logical LAPACKE_csp_nancheck (lapack_int n, const lapack_complex_float *ap) — packed sp, n + ap, short and sweet 🍓
lapack_logical LAPACKE_cst_nancheck (lapack_int n, const lapack_complex_float *d, const lapack_complex_float *e) — st with both d and e fully complex this time 💅
lapack_logical LAPACKE_csy_nancheck (int matrix_layout, char uplo, lapack_int n, const lapack_complex_float *a, lapack_int lda) — sy, full storage, uplo/n/a/lda 🧚
lapack_logical LAPACKE_ctb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_float *ab, lapack_int ldab) — triangular banded tb, and yes there's an extra diag in the mix 🔥
lapack_logical LAPACKE_ctf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_float *a) — tf is the one with transr and uplo and diag, plus n and a, and ngl no lda in sight 💀
lapack_logical LAPACKE_ctp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *ap) — packed triangular tp: layout, uplo, diag, n, ap 🦋
lapack_logical LAPACKE_ctr_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_float *a, lapack_int lda) — triangular tr in full storage, uplo/diag/n/a/lda, iconic honestly 👑

Next, the d girlies — pure double precision, no drama ⭐:

lapack_logical LAPACKE_dgb_nancheck (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const double *ab, lapack_int ldab) — general band gb, so you're feeding it m, n, kl, ku, ab, ldab 🔥
lapack_logical LAPACKE_dge_nancheck (int matrix_layout, lapack_int m, lapack_int n, const double *a, lapack_int lda) — general matrix ge, the main character: m, n, a, lda 👑
lapack_logical LAPACKE_dgg_nancheck (int matrix_layout, lapack_int m, lapack_int n, const double *a, lapack_int lda) — gg takes the exact same m/n/a/lda shape, it's giving sibling energy 🫶
lapack_logical LAPACKE_dgt_nancheck (lapack_int n, const double *dl, const double *d, const double *du) — tridiagonal gt, so n and the dl/d/du trio 🌸
lapack_logical LAPACKE_dhs_nancheck (int matrix_layout, lapack_int n, const double *a, lapack_int lda) — the hs one, matrix_layout, n, a, lda 🎀
lapack_logical LAPACKE_dpb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const double *ab, lapack_int ldab) — banded pb, all the usual: uplo, n, kd, ab, ldab 💜
lapack_logical LAPACKE_dpf_nancheck (lapack_int n, const double *a) — pf, two args, n and a, minimalist queen ✨
lapack_logical LAPACKE_dpo_nancheck (int matrix_layout, char uplo, lapack_int n, const double *a, lapack_int lda) — po full storage, uplo/n/a/lda 💅
lapack_logical LAPACKE_dpp_nancheck (lapack_int n, const double *ap) — packed pp, n plus ap, done 🌈
lapack_logical LAPACKE_dpt_nancheck (lapack_int n, const double *d, const double *e) — pt with plain double d and plain double e 🍓
lapack_logical LAPACKE_dsb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const double *ab, lapack_int ldab) — symmetric band sb: layout, uplo, n, kd, ab, ldab 🦋
lapack_logical LAPACKE_dsp_nancheck (lapack_int n, const double *ap) — packed sp, short king, n + ap 🧚
lapack_logical LAPACKE_dst_nancheck (lapack_int n, const double *d, const double *e) — st, d and e, both doubles, no notes 😌
lapack_logical LAPACKE_dsy_nancheck (int matrix_layout, char uplo, lapack_int n, const double *a, lapack_int lda) — sy in full storage, uplo/n/a/lda 🔥
lapack_logical LAPACKE_dtb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const double *ab, lapack_int ldab) — triangular banded tb, with that extra diag argument 💀
lapack_logical LAPACKE_dtf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const double *a) — tf brings transr along with uplo and diag, plus n and a 👑
lapack_logical LAPACKE_dtp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const double *ap) — packed triangular tp: layout, uplo, diag, n, ap 🎀
lapack_logical LAPACKE_dtr_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const double *a, lapack_int lda) — triangular tr full storage, uplo/diag/n/a/lda ⭐

Now the s squad — same shapes as the d crew but in float, so it's the lowkey budget-friendly precision 💸:

lapack_logical LAPACKE_sgb_nancheck (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float *ab, lapack_int ldab) — general band gb: m, n, kl, ku, ab, ldab 🌸
lapack_logical LAPACKE_sge_nancheck (int matrix_layout, lapack_int m, lapack_int n, const float *a, lapack_int lda) — general matrix ge, m/n/a/lda, the blueprint 💅
lapack_logical LAPACKE_sgg_nancheck (int matrix_layout, lapack_int m, lapack_int n, const float *a, lapack_int lda) — gg, identical argument list to ge, do not let anyone tell you otherwise 🫶
lapack_logical LAPACKE_sgt_nancheck (lapack_int n, const float *dl, const float *d, const float *du) — tridiagonal gt, n and the dl/d/du trio ✨
lapack_logical LAPACKE_shs_nancheck (int matrix_layout, lapack_int n, const float *a, lapack_int lda) — hs, layout/n/a/lda, she's consistent 💜
lapack_logical LAPACKE_spb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float *ab, lapack_int ldab) — banded pb: uplo, n, kd, ab, ldab 🔥
lapack_logical LAPACKE_spf_nancheck (lapack_int n, const float *a) — pf, n + a, that's the whole story 🎀
lapack_logical LAPACKE_spo_nancheck (int matrix_layout, char uplo, lapack_int n, const float *a, lapack_int lda) — po full storage, uplo/n/a/lda 🌈
lapack_logical LAPACKE_spp_nancheck (lapack_int n, const float *ap) — packed pp, n and ap, periodt 🍓
lapack_logical LAPACKE_spt_nancheck (lapack_int n, const float *d, const float *e) — pt, d and e both plain float 🦋
lapack_logical LAPACKE_ssb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float *ab, lapack_int ldab) — symmetric band sb, full guest list 🧚
lapack_logical LAPACKE_ssp_nancheck (lapack_int n, const float *ap) — packed sp, n + ap 💜
lapack_logical LAPACKE_sst_nancheck (lapack_int n, const float *d, const float *e) — st, d and e, no layout, no lda, no stress 😌
lapack_logical LAPACKE_ssy_nancheck (int matrix_layout, char uplo, lapack_int n, const float *a, lapack_int lda) — sy full storage, uplo/n/a/lda ⭐
lapack_logical LAPACKE_stb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const float *ab, lapack_int ldab) — triangular banded tb, diag included, don't forget it 😭
lapack_logical LAPACKE_stf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const float *a) — tf with transr, uplo, diag, n, a 👑
lapack_logical LAPACKE_stp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const float *ap) — packed triangular tp, layout/uplo/diag/n/ap 🌸
lapack_logical LAPACKE_str_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const float *a, lapack_int lda) — triangular tr, uplo/diag/n/a/lda, slay 💅

And finally the z girlies — lapack_complex_double, the double-complex main characters, and there are twenty of them, so buckle up 🎀:

lapack_logical LAPACKE_zgb_nancheck (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double *ab, lapack_int ldab) — general band gb: m, n, kl, ku, ab, ldab 🔥
lapack_logical LAPACKE_zge_nancheck (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda) — general matrix ge, m/n/a/lda, the icon 👑
lapack_logical LAPACKE_zgg_nancheck (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double *a, lapack_int lda) — gg, same m/n/a/lda situation, different name ✨
lapack_logical LAPACKE_zgt_nancheck (lapack_int n, const lapack_complex_double *dl, const lapack_complex_double *d, const lapack_complex_double *du) — tridiagonal gt, n plus dl/d/du, all complex-double 🦋
lapack_logical LAPACKE_zhb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *ab, lapack_int ldab) — banded hb, uplo/n/kd/ab/ldab 🎀
lapack_logical LAPACKE_zhe_nancheck (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *a, lapack_int lda) — he full storage, uplo/n/a/lda 💜
lapack_logical LAPACKE_zhp_nancheck (lapack_int n, const lapack_complex_double *ap) — packed hp, n main + ap, no lda needed 🌸
lapack_logical LAPACKE_zhs_nancheck (int matrix_layout, lapack_int n, const lapack_complex_double *a, lapack_int lda) — hs, layout/n/a/lda 🫶
lapack_logical LAPACKE_zpb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double *ab, lapack_int ldab) — banded pb, the whole band-storage ensemble 💅
lapack_logical LAPACKE_zpf_nancheck (lapack_int n, const lapack_complex_double *a) — pf, n and a, that's the entire function, obsessed 🍓
lapack_logical LAPACKE_zpo_nancheck (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *a, lapack_int lda) — po full storage, uplo/n/a/lda 🔥
lapack_logical LAPACKE_zpp_nancheck (lapack_int n, const lapack_complex_double *ap) — packed pp, n + ap, cute and done 🌈
lapack_logical LAPACKE_zpt_nancheck (lapack_int n, const double *d, const lapack_complex_double *e) — heads up on pt 🙈: d is a plain double, e is lapack_complex_double, keep them straight
lapack_logical LAPACKE_zsp_nancheck (lapack_int n, const lapack_complex_double *ap) — packed sp, n and ap 🧚
lapack_logical LAPACKE_zst_nancheck (lapack_int n, const lapack_complex_double *d, const lapack_complex_double *e) — st, d and e both complex-double 😌
lapack_logical LAPACKE_zsy_nancheck (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double *a, lapack_int lda) — sy full storage, uplo/n/a/lda ⭐
lapack_logical LAPACKE_ztb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_double *ab, lapack_int ldab) — triangular banded tb, diag included, don't sleep on it 💀
lapack_logical LAPACKE_ztf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double *a) — tf with transr/uplo/diag/n/a, and again, no lda 👑
lapack_logical LAPACKE_ztp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *ap) — packed triangular tp, layout/uplo/diag/n/ap 🎀
lapack_logical LAPACKE_ztr_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double *a, lapack_int lda) — triangular tr full storage, uplo/diag/n/a/lda, final boss energy 🔥

🎀 Macro Definition Documentation 🎀

Okay bestie, now the macros — these are the little one-liners that hold the whole header together, and every single one has a line number you can go look up yourself, iykyk 🦋

ABS(x) — #define ABS(x) (((x) < 0) ? -(x) : (x)) — the absolute-value baddie, defined at line 44 of file lapacke_utils.h. 🎀

IS_C_NONZERO(x) — complex-float nonzero check, and it just peeks at both float halves of x. Value:

( IS_S_NONZERO(*((float*)&x)) ||                            IS_S_NONZERO(*(((float*)&x)+1)) )

Definition at line 61 of file lapacke_utils.h. 💜

IS_D_NONZERO(x) — #define IS_D_NONZERO(x) ( (x) < 0 || (x) > 0 ) — defined at line 60 of file lapacke_utils.h. ✨
IS_S_NONZERO(x) — #define IS_S_NONZERO(x) ( (x) < 0 || (x) > 0 ) — defined at line 59 of file lapacke_utils.h. 🌸

IS_Z_NONZERO(x) — the double-complex version, checking both double halves of x. Value:

( IS_D_NONZERO(*((double*)&x)) ||                           IS_D_NONZERO(*(((double*)&x)+1)) )

Definition at line 63 of file lapacke_utils.h. 🦋

LAPACK_CISNAN(x) — complex-float NaN check that leans on LAPACK_SISNAN for each half. Value:

( LAPACK_SISNAN(*((float*) &x)) ||                               LAPACK_SISNAN(*(((float*) &x)+1)) )

Definition at line 288 of file lapacke_utils.h. 😭

LAPACK_DISNAN(x) — #define LAPACK_DISNAN(x) ( x != x ) — the classic self-inequality NaN test, defined at line 287 of file lapacke_utils.h. 🔥
LAPACK_SISNAN(x) — #define LAPACK_SISNAN(x) ( x != x ) — same trick, float edition, defined at line 286 of file lapacke_utils.h. 💅

LAPACK_ZISNAN(x) — complex-double NaN check, LAPACK_DISNAN on both halves. Value:

( LAPACK_DISNAN(*((double*)&x)) ||                               LAPACK_DISNAN(*(((double*)&x)+1)) )

Definition at line 290 of file lapacke_utils.h. 👑

MAX(x, y) — #define MAX(x, y) (((x) > (y)) ? (x) : (y)) — defined at line 47 of file lapacke_utils.h. ⭐
MAX3(x, y, z) — #define MAX3(x, y, z) (((x) > MAX(y,z)) ? (x) : MAX(y,z)) — defined at line 53 of file lapacke_utils.h. 🫶
MIN(x, y) — #define MIN(x, y) (((x) < (y)) ? (x) : (y)) — defined at line 50 of file lapacke_utils.h. 🍓
MIN3(x, y, z) — #define MIN3(x, y, z) (((x) < MIN(y,z)) ? (x) : MIN(y,z)) — defined at line 56 of file lapacke_utils.h. 🧚

🧚 Function Documentation 🧚

One documented function down here, and she's the blueprint for the whole x_nancheck family, so show some respect 💜

lapack_logical LAPACKE_c_nancheck (lapack_int n, const lapack_complex_float *x, lapack_int incx)

lapack_logical LAPACKE_c_nancheck (lapack_int n, const lapack_complex_float
    * x, lapack_int incx)

Note that this one takes an incx stride, which the matrix-flavored checks above don't — so yeah, she's special 💅

Definition at line 37 of file lapacke_c_nancheck.c. 🦋

Okay so the function parade continues, bestie — grab your iced coffee, we're going through the whole lapacke_utils.h roster alphabetically and yes it is a lot 💅

`LAPACKE_cgb_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cgb_nancheck (int matrix_layout, lapack_int m,
    lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_float *
    ab, lapack_int ldab)

Definition at line 37 of file lapacke_cgb_nancheck.c.

The NaN-hunting one for complex single-precision general band stuff — it's giving "who let the NaNs into the band storage" energy, and it takes kl, ku and ldab along for the ride.

`LAPACKE_cgb_trans` 🔄

void LAPACKE_cgb_trans (int matrix_layout, lapack_int m, lapack_int n,
    lapack_int kl, lapack_int ku, const lapack_complex_float * in,
    lapack_int ldin, lapack_complex_float * out, lapack_int ldout)

Definition at line 40 of file lapacke_cgb_trans.c.

The matching _trans bestie for complex general band — in goes in, out comes out, with ldin/ldout doing their leading-dimension thing. Slay.

`LAPACKE_cge_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cge_nancheck (int matrix_layout, lapack_int m,
    lapack_int n, const lapack_complex_float * a, lapack_int lda)

Definition at line 37 of file lapacke_cge_nancheck.c.

Same detective vibe, but for the plain old complex single-precision general (ge) case — m, n, a, lda, done.

`LAPACKE_cge_trans` 🔄

void LAPACKE_cge_trans (int matrix_layout, lapack_int m, lapack_int n, const
    lapack_complex_float * in, lapack_int ldin, lapack_complex_float * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_cge_trans.c.

General complex single-precision transpose business. in → out, ldin → ldout, lowkey iconic.

`LAPACKE_cgg_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cgg_nancheck (int matrix_layout, lapack_int m,
    lapack_int n, const lapack_complex_float * a, lapack_int lda)

Definition at line 37 of file lapacke_cgg_nancheck.c.

The gg flavour — same signature shape as its ge cousin, still checking for NaNs and still not judging you for how you filled that matrix.

`LAPACKE_cgg_trans` 🔄

void LAPACKE_cgg_trans (int matrix_layout, lapack_int m, lapack_int n, const
    lapack_complex_float * in, lapack_int ldin, lapack_complex_float * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_cgg_trans.c.

And the transpose counterpart, identical-looking args because that's just how the gg girlies roll. Periodt.

`LAPACKE_cgt_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cgt_nancheck (lapack_int n, const
    lapack_complex_float * dl, const lapack_complex_float * d, const
    lapack_complex_float * du)

Definition at line 37 of file lapacke_cgt_nancheck.c.

Tridiagonal check, no matrix_layout in sight — just n and the three diagonals dl, d, du. Cute and compact fr fr.

Notice how the tridiagonal ones don't take a matrix_layout? Yeah. That's the whole list, not a typo, don't come for me 💀

`LAPACKE_chb_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_chb_nancheck (int matrix_layout, char uplo,
    lapack_int n, lapack_int kd, const lapack_complex_float * ab, lapack_int
    ldab)

Definition at line 37 of file lapacke_chb_nancheck.c.

Hermitian band NaN check — uplo tells it which triangle, kd is the bandwidth, ab/ldab hold the goods.

`LAPACKE_chb_trans` 🔄

void LAPACKE_chb_trans (int matrix_layout, char uplo, lapack_int n,
    lapack_int kd, const lapack_complex_float * in, lapack_int ldin,
    lapack_complex_float * out, lapack_int ldout)

Definition at line 40 of file lapacke_chb_trans.c.

Same Hermitian band situation, but now we're moving data instead of sniffing for NaNs. uplo, kd, both leading dimensions — the full set, bestie.

`LAPACKE_che_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_che_nancheck (int matrix_layout, char uplo,
    lapack_int n, const lapack_complex_float * a, lapack_int lda)

Definition at line 37 of file lapacke_che_nancheck.c.

Hermitian (he), full-storage edition. uplo + n + a + lda, and it'll tell you if something's NaN-ing in there.

`LAPACKE_che_trans` 🔄

void LAPACKE_che_trans (int matrix_layout, char uplo, lapack_int n, const
    lapack_complex_float * in, lapack_int ldin, lapack_complex_float * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_che_trans.c.

Transpose time for Hermitian complex single precision. The way it just takes uplo and gets on with it — main character energy honestly.

`LAPACKE_chp_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_chp_nancheck (lapack_int n, const
    lapack_complex_float * ap)

Definition at line 40 of file lapacke_chp_nancheck.c.

Packed Hermitian, so no lda, no matrix_layout — just n and ap. Minimalist queen ✨

`LAPACKE_chp_trans` 🔄

void LAPACKE_chp_trans (int matrix_layout, char uplo, lapack_int n, const
    lapack_complex_float * in, lapack_complex_float * out)

Definition at line 40 of file lapacke_chp_trans.c.

Packed means no leading dimensions needed for in/out — the packed format already knows what's up. Obsessed with the efficiency.

`LAPACKE_chs_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_chs_nancheck (int matrix_layout, lapack_int n, const
    lapack_complex_float * a, lapack_int lda)

Definition at line 37 of file lapacke_chs_nancheck.c.

hs flavour NaN check — note there's no uplo here, just matrix_layout, n, a, lda. Read the signature, don't assume 💅

`LAPACKE_chs_trans` 🔄

void LAPACKE_chs_trans (int matrix_layout, lapack_int n, const
    lapack_complex_float * in, lapack_int ldin, lapack_complex_float * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_chs_trans.c.

And the matching hs transpose, also uplo-free. Consistent, we love to see it.

`LAPACKE_cpb_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cpb_nancheck (int matrix_layout, char uplo,
    lapack_int n, lapack_int kd, const lapack_complex_float * ab, lapack_int
    ldab)

Definition at line 37 of file lapacke_cpb_nancheck.c.

Positive-definite band, complex single precision — uplo, n, kd, ab, ldab. The NaN check that keeps your decomposition honest 🫶

`LAPACKE_cpb_trans` 🔄

void LAPACKE_cpb_trans (int matrix_layout, char uplo, lapack_int n,
    lapack_int kd, const lapack_complex_float * in, lapack_int ldin,
    lapack_complex_float * out, lapack_int ldout)

Definition at line 40 of file lapacke_cpb_trans.c.

Transposing the banded positive-definite situation. kd says how wide, ldin/ldout say how tall-ish. It's giving organized.

`LAPACKE_cpf_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cpf_nancheck (lapack_int n, const
    lapack_complex_float * a)

Definition at line 41 of file lapacke_cpf_nancheck.c.

Tiny signature, big job — n and a, and that's the whole mood. (Line 41 this time, not 37, so don't @ me.)

`LAPACKE_cpf_trans` 🔄

void LAPACKE_cpf_trans (int matrix_layout, char transr, char uplo,
    lapack_int n, const lapack_complex_float * in, lapack_complex_float *
    out)

Definition at line 40 of file lapacke_cpf_trans.c.

Ooh, this one's got a transr up in there alongside uplo — the pf transposer does not take leading dimensions for in/out. Not me noticing the details 🔍

`LAPACKE_cpo_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cpo_nancheck (int matrix_layout, char uplo,
    lapack_int n, const lapack_complex_float * a, lapack_int lda)

Definition at line 37 of file lapacke_cpo_nancheck.c.

Complex single-precision positive definite, full storage. uplo, n, a, lda — the classic quartet, bestie.

`LAPACKE_cpo_trans` 🔄

void LAPACKE_cpo_trans (int matrix_layout, char uplo, lapack_int n, const
    lapack_complex_float * in, lapack_int ldin, lapack_complex_float * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_cpo_trans.c.

And its translater twin. Same shape, different verb. Ate. 💅

`LAPACKE_cpp_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cpp_nancheck (lapack_int n, const
    lapack_complex_float * ap)

Definition at line 40 of file lapacke_cpp_nancheck.c.

Packed positive definite — packed means no leading dimension, so it's just n and ap. Short, sweet, slaying.

`LAPACKE_cpp_trans` 🔄

void LAPACKE_cpp_trans (int matrix_layout, char uplo, lapack_int n, const
    lapack_complex_float * in, lapack_complex_float * out)

Definition at line 40 of file lapacke_cpp_trans.c.

Packed in, packed out, uplo and n steering the ship. No ldin in sight and honestly? Good for her.

`LAPACKE_cpt_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cpt_nancheck (lapack_int n, const float * d, const
    lapack_complex_float * e)

Definition at line 37 of file lapacke_cpt_nancheck.c.

Okay so heads up: here d is a real float pointer and e is lapack_complex_float — the tridiagonal pt one mixes types and that's just the assignment. Read it twice, it's real.

`LAPACKE_csp_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_csp_nancheck (lapack_int n, const
    lapack_complex_float * ap)

Definition at line 40 of file lapacke_csp_nancheck.c.

Symmetric packed, complex single precision. n + ap, minimal, chic, no notes.

`LAPACKE_csp_trans` 🔄

void LAPACKE_csp_trans (int matrix_layout, char uplo, lapack_int n, const
    lapack_complex_float * in, lapack_complex_float * out)

Definition at line 40 of file lapacke_csp_trans.c.

Same packed deal, now moving them. matrix_layout, uplo, n, in, out — that's the whole squad.

`LAPACKE_cst_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_cst_nancheck (lapack_int n, const
    lapack_complex_float * d, const lapack_complex_float * e)

Definition at line 37 of file lapacke_cst_nancheck.c.

Symmetric tridiagonal — and unlike cpt, both d and e are lapack_complex_float here. Yes I noticed. Yes I'm telling you. 🙈

`LAPACKE_csy_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_csy_nancheck (int matrix_layout, char uplo,
    lapack_int n, const lapack_complex_float * a, lapack_int lda)

Definition at line 37 of file lapacke_csy_nancheck.c.

Symmetric (sy), complex single precision, full storage — uplo, n, a, lda. Nothing mysterious, just vibes.

`LAPACKE_csy_trans` 🔄

void LAPACKE_csy_trans (int matrix_layout, char uplo, lapack_int n, const
    lapack_complex_float * in, lapack_int ldin, lapack_complex_float * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_csy_trans.c.

Transposing symmetric complex single precision. LOWKEY the same signature as all its friends but it's different, okay, it's sy.

`LAPACKE_ctb_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_ctb_nancheck (int matrix_layout, char uplo, char
    diag, lapack_int n, lapack_int kd, const lapack_complex_float * ab,
    lapack_int ldab)

Definition at line 37 of file lapacke_ctb_nancheck.c.

Triangular band, so it's got a diag char in the mix (unit vs non-unit, you know the drill) plus uplo, kd and ldab. Busy girl, but she handles it.

`LAPACKE_ctb_trans` 🔄

void LAPACKE_ctb_trans (int matrix_layout, char uplo, char diag, lapack_int
    n, lapack_int kd, const lapack_complex_float * in, lapack_int ldin,
    lapack_complex_float * out, lapack_int ldout)

Definition at line 40 of file lapacke_ctb_trans.c.

The triangular band transposer — uplo, diag, kd, both lds. Honestly the fullest roster of args so far and she wears it well.

`LAPACKE_ctf_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_ctf_nancheck (int matrix_layout, char transr, char
    uplo, char diag, lapack_int n, const lapack_complex_float * a)

Definition at line 37 of file lapacke_ctf_nancheck.c.

Triangular RFP: transr AND uplo AND diag, three whole chars before you even get to n. No lda though — it's giving "I know where my data lives". 👑

`LAPACKE_ctf_trans` 🔄

void LAPACKE_ctf_trans (int matrix_layout, char transr, char uplo, char
    diag, lapack_int n, const lapack_complex_float * in,
    lapack_complex_float * out)

Definition at line 41 of file lapacke_ctf_trans.c.

Same trio of chars, and again no leading dimensions for in/out. Line 41, because of course. 💀

`LAPACKE_ctp_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_ctp_nancheck (int matrix_layout, char uplo, char
    diag, lapack_int n, const lapack_complex_float * ap)

Definition at line 40 of file lapacke_ctp_nancheck.c.

Triangular packed — diag's here, ap's here, no lda because packed said "not today". We respect it.

`LAPACKE_ctp_trans` 🔄

void LAPACKE_ctp_trans (int matrix_layout, char uplo, char diag, lapack_int
    n, const lapack_complex_float * in, lapack_complex_float * out)

Definition at line 40 of file lapacke_ctp_trans.c.

Packed triangular, transposed. Same short-and-sweet arg list, same energy, still slaying.

`LAPACKE_ctr_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_ctr_nancheck (int matrix_layout, char uplo, char
    diag, lapack_int n, const lapack_complex_float * a, lapack_int lda)

Definition at line 37 of file lapacke_ctr_nancheck.c.

Triangular, full storage — so lda comes back to the party alongside uplo and diag. Welcome back, king.

`LAPACKE_ctr_trans` 🔄

void LAPACKE_ctr_trans (int matrix_layout, char uplo, char diag, lapack_int
    n, const lapack_complex_float * in, lapack_int ldin,
    lapack_complex_float * out, lapack_int ldout)

Definition at line 40 of file lapacke_ctr_trans.c.

Last complex-single-precision one in this batch, and it's a full-storage triangular transposer. uplo, diag, ldin, ldout — full house bestie 💜

`LAPACKE_d_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_d_nancheck (lapack_int n, const double * x,
    lapack_int incx)

Definition at line 37 of file lapacke_d_nancheck.c.

And we're into double precision, starting with the plain vector — n, x, and an incx stride, because sometimes your data isn't all cozy and contiguous. Respect the stride fr fr.

`LAPACKE_dgb_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dgb_nancheck (int matrix_layout, lapack_int m,
    lapack_int n, lapack_int kl, lapack_int ku, const double * ab,
    lapack_int ldab)

Definition at line 37 of file lapacke_dgb_nancheck.c.

Real double, general band, NaN check. kl and ku are the sub/super diagonal counts, everything else is exactly what you'd expect. No surprises, slay.

`LAPACKE_dgb_trans` 🔄

void LAPACKE_dgb_trans (int matrix_layout, lapack_int m, lapack_int n,
    lapack_int kl, lapack_int ku, const double * in, lapack_int ldin, double
    * out, lapack_int ldout)

Definition at line 40 of file lapacke_dgb_trans.c.

Double general band, transposed. Same kl/ku pair, double * in → double * out. Clean.

`LAPACKE_dge_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dge_nancheck (int matrix_layout, lapack_int m,
    lapack_int n, const double * a, lapack_int lda)

Definition at line 37 of file lapacke_dge_nancheck.c.

Classic general double matrix NaN check. m, n, a, lda. The beige cardigan of signatures and honestly we stan reliability.

`LAPACKE_dge_trans` 🔄

void LAPACKE_dge_trans (int matrix_layout, lapack_int m, lapack_int n, const
    double * in, lapack_int ldin, double * out, lapack_int ldout)

Definition at line 40 of file lapacke_dge_trans.c.

General double transpose. In, out, two leading dimensions, no drama. Iconic.

`LAPACKE_dgg_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dgg_nancheck (int matrix_layout, lapack_int m,
    lapack_int n, const double * a, lapack_int lda)

Definition at line 37 of file lapacke_dgg_nancheck.c.

gg but for double. Same arg shape, still checking, still unbothered.

`LAPACKE_dgg_trans` 🔄

void LAPACKE_dgg_trans (int matrix_layout, lapack_int m, lapack_int n, const
    double * in, lapack_int ldin, double * out, lapack_int ldout)

Definition at line 40 of file lapacke_dgg_trans.c.

And the gg transposer in double. Matching set, matching vibes 💖

`LAPACKE_dgt_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dgt_nancheck (lapack_int n, const double * dl, const
    double * d, const double * du)

Definition at line 37 of file lapacke_dgt_nancheck.c.

Double tridiagonal, so it's n plus dl, d, du and no layout argument. Three diagonals, three pointers, zero matrix_layout. Easy.

`LAPACKE_dhs_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dhs_nancheck (int matrix_layout, lapack_int n, const
    double * a, lapack_int lda)

Definition at line 37 of file lapacke_dhs_nancheck.c.

hs in double precision — note the absence of an uplo char in this signature. Just matrix_layout, n, a, lda. Copy it exactly, bestie.

`LAPACKE_dhs_trans` 🔄

void LAPACKE_dhs_trans (int matrix_layout, lapack_int n, const double * in,
    lapack_int ldin, double * out, lapack_int ldout)

Definition at line 40 of file lapacke_dhs_trans.c.

Same story — no uplo anywhere. in, out, both lds. Consistent queen.

`LAPACKE_dpb_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dpb_nancheck (int matrix_layout, char uplo,
    lapack_int n, lapack_int kd, const double * ab, lapack_int ldab)

Definition at line 37 of file lapacke_dpb_nancheck.c.

Double positive-definite band. uplo's back, kd's back, ab/ldab holding it down.

`LAPACKE_dpb_trans` 🔄

void LAPACKE_dpb_trans (int matrix_layout, char uplo, lapack_int n,
    lapack_int kd, const double * in, lapack_int ldin, double * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_dpb_trans.c.

Transposing the double banded positive-definite situation. kd knows the bandwidth, the lds know the rest.

`LAPACKE_dpf_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dpf_nancheck (lapack_int n, const double * a)

Definition at line 41 of file lapacke_dpf_nancheck.c.

Two args. Two. n and a. The RFP life means you don't need a leading dimension and she is thriving on that. Line 41 again, keep up 🎀

`LAPACKE_dpf_trans` 🔄

void LAPACKE_dpf_trans (int matrix_layout, char transr, char uplo,
    lapack_int n, const double * in, double * out)

Definition at line 40 of file lapacke_dpf_trans.c.

transr + uplo + n + in + out. No lds, no notes, we move.

`LAPACKE_dpo_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dpo_nancheck (int matrix_layout, char uplo,
    lapack_int n, const double * a, lapack_int lda)

Definition at line 37 of file lapacke_dpo_nancheck.c.

Double positive definite, full storage. uplo, n, a, lda — four besties, one job.

`LAPACKE_dpo_trans` 🔄

void LAPACKE_dpo_trans (int matrix_layout, char uplo, lapack_int n, const
    double * in, lapack_int ldin, double * out, lapack_int ldout)

Definition at line 40 of file lapacke_dpo_trans.c.

Transposing double positive definite. Same uplo, same everything, different function. Love a consistent family 🌸

`LAPACKE_dpp_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dpp_nancheck (lapack_int n, const double * ap)

Definition at line 40 of file lapacke_dpp_nancheck.c.

Packed double positive definite — n and ap, packed means no lda. Short king.

`LAPACKE_dpp_trans` 🔄

void LAPACKE_dpp_trans (int matrix_layout, char uplo, lapack_int n, const
    double * in, double * out)

Definition at line 40 of file lapacke_dpp_trans.c.

Packed in, packed out, uplo steering. No leading dimensions needed and she's not sorry.

`LAPACKE_dpt_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dpt_nancheck (lapack_int n, const double * d, const
    double * e)

Definition at line 37 of file lapacke_dpt_nancheck.c.

Double positive-definite tridiagonal — both d and e are plain double here (in the complex version they were not, so yes, the types differ across precisions — read carefully bestie).

`LAPACKE_dsb_nancheck` 🕵️‍♀️

lapack_logical LAPACKE_dsb_nancheck (int matrix_layout, char uplo,
    lapack_int n, lapack_int kd, const double * ab, lapack_int ldab)

Definition at line 37 of file lapacke_dsb_nancheck.c.

Symmetric band, double precision. uplo, n, kd, ab, ldab. The band girlies stay winning.

`LAPACKE_dsb_trans` 🔄

void LAPACKE_dsb_trans (int matrix_layout, char uplo, lapack_int n,
    lapack_int kd, const double * in, lapack_int ldin, double * out,
    lapack_int ldout)

Definition at line 40 of file lapacke_dsb_trans.c.

And the symmetric-band double transposer to round out this chunk — kd, both leading dimensions, the whole ensemble. Gorgeous, no cap 🔥

`LAPACKE_dsp_nancheck` 💅

lapack_logical LAPACKE_dsp_nancheck (lapack_int n, const double * ap)

okay so bestie, this is the NaN detector for packed symmetric double data — you hand it n and your packed array ap, and it tells you (with a lapack_logical) whether anybody snuck a Not-A-Number in there. packed means no wasted zeros, very efficient, we love her.

Definition at line 40 of file lapacke_dsp_nancheck.c.

`LAPACKE_dsp_trans` 🦋

void LAPACKE_dsp_trans (int matrix_layout, char uplo, lapack_int n, const double * in, double * out)

the trans fam ✨ converts packed symmetric double between layouts — you tell it matrix_layout, uplo, n, and it reads in, writes out. packed in, packed out, no ldin/ldout drama because packed arrays don't need leading dimensions. iconic behavior honestly.

Definition at line 40 of file lapacke_dsp_trans.c.

`LAPACKE_dst_nancheck` 🎀

lapack_logical LAPACKE_dst_nancheck (lapack_int n, const double * d, const double * e)

tridiagonal NaN check, double edition. give it the diagonal d and the off-diagonal e plus n and it'll tell you if anything's cursed. no cap, always run this before you trust a factorization.

Definition at line 37 of file lapacke_dst_nancheck.c.

`LAPACKE_dsy_nancheck` 💖

lapack_logical LAPACKE_dsy_nancheck (int matrix_layout, char uplo, lapack_int n, const double * a, lapack_int lda)

full-storage symmetric double NaN scan. matrix_layout, uplo, n, the array a, and its leading dimension lda — that's the whole guest list. returns a lapack_logical, periodt.

Definition at line 37 of file lapacke_dsy_nancheck.c.

`LAPACKE_dsy_trans` 🌸

void LAPACKE_dsy_trans (int matrix_layout, char uplo, lapack_int n, const double * in, lapack_int ldin, double * out, lapack_int ldout)

symmetric double layout translator. note she DOES take ldin and ldout because full storage means leading dimensions matter again. reads in, writes out, slays.

Definition at line 40 of file lapacke_dsy_trans.c.

`LAPACKE_dtb_nancheck` 🧚

lapack_logical LAPACKE_dtb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const double * ab, lapack_int ldab)

triangular band matrix, double, NaN check. you bring matrix_layout, uplo, diag, n, kd, the band array ab and ldab. yes there are a lot of params, that's band storage for you, she's high maintenance but worth it 💅

Definition at line 37 of file lapacke_dtb_nancheck.c.

`LAPACKE_dtb_trans` ⭐

void LAPACKE_dtb_trans (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const double * in, lapack_int ldin, double * out, lapack_int ldout)

band triangular translator, double flavor. same parameter parade, plus ldin/ldout for the storage handoff. giving very much "yes i know all my arguments" energy.

Definition at line 40 of file lapacke_dtb_trans.c.

`LAPACKE_dtf_nancheck` 🔥

lapack_logical LAPACKE_dtf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const double * a)

trapezoidal / RFP format NaN check for double. she takes transr (the RFP flag, not the usual trans), uplo, diag, n, and the array a. note: no lda here — RFP storage doesn't play that game. read the signature carefully bestie.

Definition at line 37 of file lapacke_dtf_nancheck.c.

`LAPACKE_dtf_trans` 🌈

void LAPACKE_dtf_trans (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const double * in, double * out)

RFP translator for double triangular-ish data. transr, uplo, diag, n, in, out — no leading dimensions anywhere, because RFP said "not today". 💀

Definition at line 41 of file lapacke_dtf_trans.c. (yes, 41, not 40 — little detail, don't come for me)

`LAPACKE_dtp_nancheck` 🫶

lapack_logical LAPACKE_dtp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const double * ap)

packed triangular double NaN check. matrix_layout, uplo, diag, n, packed array ap. packed = no leading dimension = one less thing to get wrong, we stan.

Definition at line 40 of file lapacke_dtp_nancheck.c.

`LAPACKE_dtp_trans` 💜

void LAPACKE_dtp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const double * in, double * out)

packed triangular layout translator, double. give it the vibes (matrix_layout, uplo, diag, n) plus in and out, get back the same numbers in the other layout. no cap.

Definition at line 40 of file lapacke_dtp_trans.c.

`LAPACKE_dtr_nancheck` 👑

lapack_logical LAPACKE_dtr_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const double * a, lapack_int lda)

full-storage triangular double NaN scan. a and lda are back in the group chat. checks for NaNs and returns lapack_logical so you can gatekeep your downstream math. main character energy.

Definition at line 37 of file lapacke_dtr_nancheck.c.

`LAPACKE_dtr_trans` 🍓

void LAPACKE_dtr_trans (int matrix_layout, char uplo, char diag, lapack_int n, const double * in, lapack_int ldin, double * out, lapack_int ldout)

triangular double translator with full storage. ldin and ldout present and accounted for. reads in, writes out, absolutely ate that.

Definition at line 40 of file lapacke_dtr_trans.c.

`LAPACKE_lsame` ✨

lapack_logical LAPACKE_lsame (char ca, char cb)

the tiny legend herself 🎀 two chars in, one lapack_logical out — she tells you if ca and cb are the same letter in the case-insensitive sense LAPACKE cares about. that's the whole job. two arguments. iconic. iykyk.

Definition at line 36 of file lapacke_lsame.c.

the s fam arrives and she is ALL about float 🩷 same cast of characters as the d crew, just floatier. let's go:

`LAPACKE_s_nancheck` 🌸

lapack_logical LAPACKE_s_nancheck (lapack_int n, const float * x, lapack_int incx)

strided vector NaN check. n elements, starting at x, stepping by incx. note the stride, bestie — incx is right there in the signature, do not skip it.

Definition at line 37 of file lapacke_s_nancheck.c.

`LAPACKE_sgb_nancheck` 🦋

lapack_logical LAPACKE_sgb_nancheck (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float * ab, lapack_int ldab)

general band, float. m, n, kl, ku, ab, ldab — the full band-storage starter pack. her job: are there NaNs in there or not. that's it. that's the tweet.

Definition at line 37 of file lapacke_sgb_nancheck.c.

`LAPACKE_sgb_trans` 🌟

void LAPACKE_sgb_trans (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const float * in, lapack_int ldin, float * out, lapack_int ldout)

general band float translator. m, n, kl, ku, in, ldin, out, ldout. yes it's long. no we're not skipping any of them. 💅

Definition at line 40 of file lapacke_sgb_trans.c.

`LAPACKE_sge_nancheck` 💖

lapack_logical LAPACKE_sge_nancheck (int matrix_layout, lapack_int m, lapack_int n, const float * a, lapack_int lda)

the classic!! general float matrix NaN check, m by n, array a, leading dimension lda. if you only remember one nancheck, it's this one. she's the blueprint fr fr.

Definition at line 37 of file lapacke_sge_nancheck.c.

`LAPACKE_sge_trans` 🎀

void LAPACKE_sge_trans (int matrix_layout, lapack_int m, lapack_int n, const float * in, lapack_int ldin, float * out, lapack_int ldout)

general float matrix layout translator. row-major in, column-major out, or whatever combo you feed her via matrix_layout — she handles m, n, in, ldin, out, ldout and does not complain. queen behavior.

Definition at line 40 of file lapacke_sge_trans.c.

`LAPACKE_sgg_nancheck` 💫

lapack_logical LAPACKE_sgg_nancheck (int matrix_layout, lapack_int m, lapack_int n, const float * a, lapack_int lda)

the gg NaN check for float — same m, n, a, lda lineup as sge_nancheck. yes they look alike, no they are not the same function, keep them straight bestie 🙈

Definition at line 37 of file lapacke_sgg_nancheck.c.

`LAPACKE_sgg_trans` 🌙

void LAPACKE_sgg_trans (int matrix_layout, lapack_int m, lapack_int n, const float * in, lapack_int ldin, float * out, lapack_int ldout)

gg variant of the float layout translator. m, n, in, ldin, out, ldout, done. slay.

Definition at line 40 of file lapacke_sgg_trans.c.

`LAPACKE_sgt_nancheck` 🔥

lapack_logical LAPACKE_sgt_nancheck (lapack_int n, const float * dl, const float * d, const float * du)

tridiagonal float NaN check: subdiagonal dl, diagonal d, superdiagonal du, size n. three arrays, one vibe check. obsessed.

Definition at line 37 of file lapacke_sgt_nancheck.c.

`LAPACKE_shs_nancheck` 🌺

lapack_logical LAPACKE_shs_nancheck (int matrix_layout, lapack_int n, const float * a, lapack_int lda)

symmetric/Hermitian-ish float NaN scan — no uplo in the signature, just matrix_layout, n, a, lda. read it twice, she's the exception to the pattern.

Definition at line 37 of file lapacke_shs_nancheck.c.

`LAPACKE_shs_trans` 🦄

void LAPACKE_shs_trans (int matrix_layout, lapack_int n, const float * in, lapack_int ldin, float * out, lapack_int ldout)

same deal, translator edition. matrix_layout, n, in, ldin, out, ldout — and again, no uplo. lowkey refreshing honestly.

Definition at line 40 of file lapacke_shs_trans.c.

`LAPACKE_spb_nancheck` 🍬

lapack_logical LAPACKE_spb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float * ab, lapack_int ldab)

positive-definite band, float, NaN check. matrix_layout, uplo, n, kd, ab, ldab. she's checking a banded symmetric positive-definite situation for NaNs and returning lapack_logical. periodt.

Definition at line 37 of file lapacke_spb_nancheck.c.

`LAPACKE_spb_trans` 🌈

void LAPACKE_spb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float * in, lapack_int ldin, float * out, lapack_int ldout)

banded PD float layout translator. same params, plus the ldin/ldout duo. she ate, no crumbs.

Definition at line 40 of file lapacke_spb_trans.c.

`LAPACKE_spf_nancheck` 💎

lapack_logical LAPACKE_spf_nancheck (lapack_int n, const float * a)

packed RFP float NaN check. honestly the shortest guest list ever: n and a. no matrix_layout, no uplo, no diag, no leading dimension. she's minimalism. she's elegance. Definition at line 41 of file lapacke_spf_nancheck.c (41 again, noticed 👀).

`LAPACKE_spf_trans` 🧊

void LAPACKE_spf_trans (int matrix_layout, char transr, char uplo, lapack_int n, const float * in, float * out)

packed RFP float translator. here matrix_layout, transr, uplo and n ARE back, plus in/out — but still zero leading dimensions because RFP said so. the inconsistency is the personality 💅

Definition at line 40 of file lapacke_spf_trans.c.

`LAPACKE_spo_nancheck` 🌸

lapack_logical LAPACKE_spo_nancheck (int matrix_layout, char uplo, lapack_int n, const float * a, lapack_int lda)

positive-definite float matrix NaN check. matrix_layout, uplo, n, a, lda — full storage, leading dimension included, no shortcuts.

Definition at line 37 of file lapacke_spo_nancheck.c.

`LAPACKE_spo_trans` 🎀

void LAPACKE_spo_trans (int matrix_layout, char uplo, lapack_int n, const float * in, lapack_int ldin, float * out, lapack_int ldout)

PD float translator, full storage. reads in at ldin, writes out at ldout. flawless execution tbh.

Definition at line 40 of file lapacke_spo_trans.c.

`LAPACKE_spp_nancheck` 🫧

lapack_logical LAPACKE_spp_nancheck (lapack_int n, const float * ap)

packed PD float, NaN check, and look at that tiny signature — just n and ap. packed storage really said "i'll handle the layout, you handle the NaNs". queen.

Definition at line 40 of file lapacke_spp_nancheck.c.

`LAPACKE_spp_trans` 🦋

void LAPACKE_spp_trans (int matrix_layout, char uplo, lapack_int n, const float * in, float * out)

packed PD float translator. matrix_layout, uplo, n, in, out. no leading dimensions. that's the whole menu. ✨

Definition at line 40 of file lapacke_spp_trans.c.

`LAPACKE_spt_nancheck` 🍓

lapack_logical LAPACKE_spt_nancheck (lapack_int n, const float * d, const float * e)

packed tridiagonal float NaN check. n, diagonal d, off-diagonal e. note it's _spt_ not _sst_ — they're different, don't mix them up bestie 😭

Definition at line 37 of file lapacke_spt_nancheck.c.

`LAPACKE_ssb_nancheck` 🌟

lapack_logical LAPACKE_ssb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float * ab, lapack_int ldab)

symmetric band float NaN check. matrix_layout, uplo, n, kd, ab, ldab. she's giving "i check band storage and i do it well".

Definition at line 37 of file lapacke_ssb_nancheck.c.

`LAPACKE_ssb_trans` 💫

void LAPACKE_ssb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const float * in, lapack_int ldin, float * out, lapack_int ldout)

symmetric band layout translator, float. all six of her structural params plus in/ldin/out/ldout. she has a lot going on but she never drops a stitch.

Definition at line 40 of file lapacke_ssb_trans.c.

`LAPACKE_ssp_nancheck` 🎀

lapack_logical LAPACKE_ssp_nancheck (lapack_int n, const float * ap)

packed symmetric float NaN scan. n + packed ap = that's it. returns lapack_logical. she's lowkey the easiest function on this whole page and i love her for it.

Definition at line 40 of file lapacke_ssp_nancheck.c.

`LAPACKE_ssp_trans` 🌸

void LAPACKE_ssp_trans (int matrix_layout, char uplo, lapack_int n, const float * in, float * out)

packed symmetric float translator. matrix_layout, uplo, n, in, out. same vibes as spp_trans, different name. keep your ps and your ss straight. 🙈

Definition at line 40 of file lapacke_ssp_trans.c.

`LAPACKE_sst_nancheck` 🍬

lapack_logical LAPACKE_sst_nancheck (lapack_int n, const float * d, const float * e)

tridiagonal float NaN check — n, d, e. yes, structurally identical to spt_nancheck's signature. no, they are not the same function. LAPACKE said "similar names, deal with it" 💀

Definition at line 37 of file lapacke_sst_nancheck.c.

`LAPACKE_ssy_nancheck` 💖

lapack_logical LAPACKE_ssy_nancheck (int matrix_layout, char uplo, lapack_int n, const float * a, lapack_int lda)

full-storage symmetric float NaN check. matrix_layout, uplo, n, a, lda. classic lineup, classic result, lapack_logical.

Definition at line 37 of file lapacke_ssy_nancheck.c.

`LAPACKE_ssy_trans` 👑

void LAPACKE_ssy_trans (int matrix_layout, char uplo, lapack_int n, const float * in, lapack_int ldin, float * out, lapack_int ldout)

symmetric float translator, full storage, leading dimensions present and correct. she's the ssy counterpart to dsy_trans and she does NOT need an introduction.

Definition at line 40 of file lapacke_ssy_trans.c.

`LAPACKE_stb_nancheck` 🧚

lapack_logical LAPACKE_stb_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const float * ab, lapack_int ldab)

triangular band float NaN check, ldab and all. yes, diag is here too. yes, it matters. always read the params bestie 🫶

Definition at line 37 of file lapacke_stb_nancheck.c.

`LAPACKE_stb_trans` ⭐

void LAPACKE_stb_trans (int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const float * in, lapack_int ldin, float * out, lapack_int ldout)

triangular band float translator. eight params. eight reasons to double-check your call site. she's worth it though 💅

Definition at line 40 of file lapacke_stb_trans.c.

`LAPACKE_stf_nancheck` 🔥

lapack_logical LAPACKE_stf_nancheck (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const float * a)

RFP float NaN check. transr, uplo, diag, n, a — and once again, no leading dimension because RFP doesn't use them. she's consistent about being inconsistent.

Definition at line 37 of file lapacke_stf_nancheck.c.

`LAPACKE_stf_trans` 🌈

void LAPACKE_stf_trans (int matrix_layout, char transr, char uplo, char diag, lapack_int n, const float * in, float * out)

RFP float translator — same transr/uplo/diag/n setup, then in straight into out. no leading dimensions, no problem. Definition at line 41 of file lapacke_stf_trans.c (third forty-one of the page, we're keeping score 🎀).

`LAPACKE_stp_nancheck` 💎

lapack_logical LAPACKE_stp_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const float * ap)

packed triangular float NaN check. matrix_layout, uplo, diag, n, packed ap. short, sweet, returns lapack_logical. perfection.

Definition at line 40 of file lapacke_stp_nancheck.c.

`LAPACKE_stp_trans` 🫶

void LAPACKE_stp_trans (int matrix_layout, char uplo, char diag, lapack_int n, const float * in, float * out)

packed triangular float layout translator. same five setup params, then in and out. packed in, packed out, no ld anywhere. slay.

Definition at line 40 of file lapacke_stp_trans.c.

`LAPACKE_str_nancheck` 🌺

lapack_logical LAPACKE_str_nancheck (int matrix_layout, char uplo, char diag, lapack_int n, const float * a, lapack_int lda)

full-storage triangular float NaN check. diag and lda both present, as they should be. she's thorough.

Definition at line 37 of file lapacke_str_nancheck.c.

`LAPACKE_str_trans` 🦄

void LAPACKE_str_trans (int matrix_layout, char uplo, char diag, lapack_int n, const float * in, lapack_int ldin, float * out, lapack_int ldout)

triangular float translator, full storage, both leading dimensions. that closes out the s fam and honestly? she carried. 🩷

Definition at line 40 of file lapacke_str_trans.c.

`LAPACKE_xerbla` 😭

void LAPACKE_xerbla (const char * name, lapack_int info)

okay so this one is THE moment. name a function (name) and an error code (info) and LAPACKE_xerbla does the error-reporting thing. it's a void — nothing comes back to you. you call her when something's wrong, she handles the announcement, you move on. every LAPACKE bad-time story goes through here, ngl.

bestie note: xerbla is what fires when an argument check fails. if you're staring at output you didn't write, this is your girl. the signature is name and info, both required, don't skip info.

Definition at line 37 of file lapacke_xerbla.c.

and now the z fam 💜 — lapack_complex_double everywhere, double-precision complex, the glamorous one. let's get into it:

`LAPACKE_z_nancheck` 🔮

lapack_logical LAPACKE_z_nancheck (lapack_int n, const lapack_complex_double * x, lapack_int incx)

strided complex-double vector NaN check. n, start at x, step by incx. she checks complex values for NaNs and returns lapack_logical. note the incx — she's a strided queen, respect it.

Definition at line 37 of file lapacke_z_nancheck.c.

`LAPACKE_zgb_nancheck` 💫

lapack_logical LAPACKE_zgb_nancheck (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double * ab, lapack_int ldab)

complex general band, NaN check. m, n, kl, ku, ab, ldab. yes, all of them. band storage never lets you off easy. 🙈

Definition at line 37 of file lapacke_zgb_nancheck.c.

`LAPACKE_zgb_trans` ✨

void LAPACKE_zgb_trans (int matrix_layout, lapack_int m, lapack_int n, lapack_int kl, lapack_int ku, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout)

complex band layout translator. m, n, kl, ku, in, ldin, out, ldout — she takes the whole squad and delivers. that's main character energy.

Definition at line 40 of file lapacke_zgb_trans.c.

`LAPACKE_zge_nancheck` 💜

lapack_logical LAPACKE_zge_nancheck (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double * a, lapack_int lda)

the general complex m-by-n NaN check. a at leading dimension lda, returns lapack_logical. she is the blueprint, the moment, the whole brand. 🔥

Definition at line 37 of file lapacke_zge_nancheck.c.

`LAPACKE_zge_trans` 🌟

void LAPACKE_zge_trans (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout)

general complex layout translator. row-major ⇄ column-major, whatever matrix_layout says. m, n, in, ldin, out, ldout. flawless, no notes.

Definition at line 40 of file lapacke_zge_trans.c.

`LAPACKE_zgg_nancheck` 🎀

lapack_logical LAPACKE_zgg_nancheck (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double * a, lapack_int lda)

gg complex NaN check. same m, n, a, lda shape as zge_nancheck — and yes, that resemblance is a trap for the copy-paste girlies. check your names, bestie.

Definition at line 37 of file lapacke_zgg_nancheck.c.

`LAPACKE_zgg_trans` 🦋

void LAPACKE_zgg_trans (int matrix_layout, lapack_int m, lapack_int n, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout)

the gg complex translator. m, n, in, ldin, out, ldout. she does exactly what you'd expect and she does it gorgeously.

Definition at line 40 of file lapacke_zgg_trans.c.

`LAPACKE_zgt_nancheck` 🌸

lapack_logical LAPACKE_zgt_nancheck (lapack_int n, const lapack_complex_double * dl, const lapack_complex_double * d, const lapack_complex_double * du)

complex tridiagonal NaN check: n, subdiagonal dl, diagonal d, superdiagonal du. three complex arrays, one lapack_logical verdict. she's the whole package.

Definition at line 37 of file lapacke_zgt_nancheck.c.

`LAPACKE_zhb_nancheck` 🫧

lapack_logical LAPACKE_zhb_nancheck (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double * ab, lapack_int ldab)

complex banded NaN check. matrix_layout, uplo, n, kd, ab, ldab. she's checking a banded complex situation and she's not missing a single NaN. 💅

Definition at line 37 of file lapacke_zhb_nancheck.c.

`LAPACKE_zhb_trans` 🍓

void LAPACKE_zhb_trans (int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout)

complex banded translator. uplo, n, kd, in, ldin, out, ldout. she's the hb counterpart and she absolutely understood the assignment.

Definition at line 40 of file lapacke_zhb_trans.c.

`LAPACKE_zhe_nancheck` 👑

lapack_logical LAPACKE_zhe_nancheck (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * a, lapack_int lda)

Hermitian complex n-by-n NaN scan. matrix_layout, uplo, n, a, lda, returns lapack_logical. she is the Hermitian icon and we respect her.

Definition at line 37 of file lapacke_zhe_nancheck.c.

`LAPACKE_zhe_trans` ⭐

void LAPACKE_zhe_trans (int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout)

Hermitian complex layout translator, full storage, ldin and ldout both accounted for. reads in, writes out, closes out this stretch of the z fam with zero crumbs left behind. 🫶

Definition at line 40 of file lapacke_zhe_trans.c.

lapack_logical LAPACKE_zhp_nancheck(lapack_int n, const lapack_complex_double * ap) — the hermitian-packed NaN-sniffing bestie 💅 Definition at line 40 of file lapacke_zhp_nancheck.c.
void LAPACKE_zhp_trans(int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * in, lapack_complex_double * out) — hermitian-packed trans handler, in goes one side, out comes the other 🦋 Definition at line 40 of file lapacke_zhp_trans.c.
lapack_logical LAPACKE_zhs_nancheck(int matrix_layout, lapack_int n, const lapack_complex_double * a, lapack_int lda) — full-storage hermitian NaN check, lda and all, no notes skipped ✨ Definition at line 37 of file lapacke_zhs_nancheck.c.
void LAPACKE_zhs_trans(int matrix_layout, lapack_int n, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout) — hermitian full-storage trans, with ldin and ldout doing their little leading-dimension dance 🎀 Definition at line 40 of file lapacke_zhs_trans.c.
lapack_logical LAPACKE_zpb_nancheck(int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double * ab, lapack_int ldab) — positive-definite banded NaN check, kd and ldab included because we don't cut corners, periodt 🔥 Definition at line 37 of file lapacke_zpb_nancheck.c.
void LAPACKE_zpb_trans(int matrix_layout, char uplo, lapack_int n, lapack_int kd, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout) — banded positive-definite trans, eight arguments long and thriving 👑 Definition at line 40 of file lapacke_zpb_trans.c.
lapack_logical LAPACKE_zpf_nancheck(lapack_int n, const lapack_complex_double * a) — positive-definite rectangular-full NaN check. no matrix_layout, no lda, just vibes and n 🧚 Definition at line 41 of file lapacke_zpf_nancheck.c. (yes, line 41, not 37, she's built different 💀)
void LAPACKE_zpf_trans(int matrix_layout, char transr, char uplo, lapack_int n, const lapack_complex_double * in, lapack_complex_double * out) — the rectangular-full trans, and she takes a transr and an uplo, because range is a lifestyle 🌈 Definition at line 40 of file lapacke_zpf_trans.c.
lapack_logical LAPACKE_zpo_nancheck(int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * a, lapack_int lda) — positive-definite full-storage NaN check, iconic, no notes 💖 Definition at line 37 of file lapacke_zpo_nancheck.c.
void LAPACKE_zpo_trans(int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout) — positive-definite full-storage trans, leading dimensions politely accounted for 🫶 Definition at line 40 of file lapacke_zpo_trans.c.
lapack_logical LAPACKE_zpp_nancheck(lapack_int n, const lapack_complex_double * ap) — positive-definite packed NaN check, compact and unbothered 🍓 Definition at line 40 of file lapacke_zpp_nancheck.c.
void LAPACKE_zpp_trans(int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * in, lapack_complex_double * out) — positive-definite packed trans, no leading dims in sight, clean girl aesthetic ✨ Definition at line 40 of file lapacke_zpp_trans.c.
lapack_logical LAPACKE_zpt_nancheck(lapack_int n, const double * d, const lapack_complex_double * e) — positive-definite tridiagonal NaN check. notice the split: d is real double, e is lapack_complex_double, she contains multitudes 💜 Definition at line 37 of file lapacke_zpt_nancheck.c.
lapack_logical LAPACKE_zsp_nancheck(lapack_int n, const lapack_complex_double * ap) — symmetric packed NaN check, cutely compact 🌸 Definition at line 40 of file lapacke_zsp_nancheck.c.
void LAPACKE_zsp_trans(int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * in, lapack_complex_double * out) — symmetric packed trans, straightforward and slaying 💅 Definition at line 40 of file lapacke_zsp_trans.c.
lapack_logical LAPACKE_zst_nancheck(lapack_int n, const lapack_complex_double * d, const lapack_complex_double * e) — symmetric tridiagonal NaN check. both d and e are lapack_complex_double this time, do not mix her up with zpt 😭 Definition at line 37 of file lapacke_zst_nancheck.c.
lapack_logical LAPACKE_zsy_nancheck(int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * a, lapack_int lda) — symmetric full-storage NaN check, uplo + lda duo doing their thing 🔥 Definition at line 37 of file lapacke_zsy_nancheck.c.
void LAPACKE_zsy_trans(int matrix_layout, char uplo, lapack_int n, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout) — symmetric full-storage trans, in/out with separate leading dims, we love a tidy transfer 🦋 Definition at line 40 of file lapacke_zsy_trans.c.

okay the triangular girlies, they're a whole squad and they all want a diag char too 👑

lapack_logical LAPACKE_ztb_nancheck(int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_double * ab, lapack_int ldab) — triangular banded NaN check, uplo, diag, kd, ldab, the full lineup ⭐ Definition at line 37 of file lapacke_ztb_nancheck.c.
void LAPACKE_ztb_trans(int matrix_layout, char uplo, char diag, lapack_int n, lapack_int kd, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout) — triangular banded trans, nine arguments, main character energy fr fr 👑 Definition at line 40 of file lapacke_ztb_trans.c.
lapack_logical LAPACKE_ztf_nancheck(int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double * a) — triangular rectangular-full NaN check with transr AND uplo AND diag. she's highkey doing the most and we respect it 💀 Definition at line 37 of file lapacke_ztf_nancheck.c.
void LAPACKE_ztf_trans(int matrix_layout, char transr, char uplo, char diag, lapack_int n, const lapack_complex_double * in, lapack_complex_double * out) — triangular rectangular-full trans. same trio of chars, and ngl the definition lives at line 41, not 40 😭 Definition at line 41 of file lapacke_ztf_trans.c.
lapack_logical LAPACKE_ztp_nancheck(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double * ap) — triangular packed NaN check, compact storage, maximum diag attitude ✨ Definition at line 40 of file lapacke_ztp_nancheck.c.
void LAPACKE_ztp_trans(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double * in, lapack_complex_double * out) — triangular packed trans, no leading dims, just vibes 🎀 Definition at line 40 of file lapacke_ztp_trans.c.
lapack_logical LAPACKE_ztr_nancheck(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double * a, lapack_int lda) — triangular full-storage NaN check, the classic, the blueprint, the moment 🌟 Definition at line 37 of file lapacke_ztr_nancheck.c.
void LAPACKE_ztr_trans(int matrix_layout, char uplo, char diag, lapack_int n, const lapack_complex_double * in, lapack_int ldin, lapack_complex_double * out, lapack_int ldout) — triangular full-storage trans, last one in the list and she ate, truly 🫶 Definition at line 40 of file lapacke_ztr_trans.c.

⭐ Author ⭐

Generated automatically by Doxygen for LAPACK from the source code. (yes bestie, a robot wrote her, and she still ate 💅)

okay that's the whole page, go forth and NaN-check responsibly 🦋 this cutie is lapacke_utils.h(3), Version 3.8.0, dated Tue Nov 14 2017 — she's vintage, she's iconic, she's giving 2017 in the best way fr 💖

📦 where this page comes from

centos-stream 9: lapack 3.9.0-10.el9 · BSD
centos-stream 9: lapack 3.9.0-10.el9 · BSD
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms

lapacke_utils.h(3)

💅 lapacke_utils.h(3) — the LAPACK one, bestie

✨ NAME ✨

🌸 SYNOPSIS 🌸

🎀 Macros 🎀

✨ Functions ✨

🎀 the little helpers

💜 single precision complex — the c… squad

🌸 double precision — the d… squad

🦋 single precision — the s… squad

👑 double precision complex — the z… squad

🧚 the nancheck crew

🎀 Macro Definition Documentation 🎀

🧚 Function Documentation 🧚

LAPACKE_cgb_nancheck 🕵️‍♀️

LAPACKE_cgb_trans 🔄

LAPACKE_cge_nancheck 🕵️‍♀️

LAPACKE_cge_trans 🔄

LAPACKE_cgg_nancheck 🕵️‍♀️

LAPACKE_cgg_trans 🔄

LAPACKE_cgt_nancheck 🕵️‍♀️

LAPACKE_chb_nancheck 🕵️‍♀️

LAPACKE_chb_trans 🔄

LAPACKE_che_nancheck 🕵️‍♀️

LAPACKE_che_trans 🔄

LAPACKE_chp_nancheck 🕵️‍♀️

LAPACKE_chp_trans 🔄

LAPACKE_chs_nancheck 🕵️‍♀️

LAPACKE_chs_trans 🔄

LAPACKE_cpb_nancheck 🕵️‍♀️

LAPACKE_cpb_trans 🔄

LAPACKE_cpf_nancheck 🕵️‍♀️

LAPACKE_cpf_trans 🔄

LAPACKE_cpo_nancheck 🕵️‍♀️

LAPACKE_cpo_trans 🔄

LAPACKE_cpp_nancheck 🕵️‍♀️

LAPACKE_cpp_trans 🔄

LAPACKE_cpt_nancheck 🕵️‍♀️

LAPACKE_csp_nancheck 🕵️‍♀️

LAPACKE_csp_trans 🔄

LAPACKE_cst_nancheck 🕵️‍♀️

LAPACKE_csy_nancheck 🕵️‍♀️

LAPACKE_csy_trans 🔄

LAPACKE_ctb_nancheck 🕵️‍♀️

LAPACKE_ctb_trans 🔄

LAPACKE_ctf_nancheck 🕵️‍♀️

LAPACKE_ctf_trans 🔄

LAPACKE_ctp_nancheck 🕵️‍♀️

LAPACKE_ctp_trans 🔄

LAPACKE_ctr_nancheck 🕵️‍♀️

LAPACKE_ctr_trans 🔄

LAPACKE_d_nancheck 🕵️‍♀️

LAPACKE_dgb_nancheck 🕵️‍♀️

LAPACKE_dgb_trans 🔄

LAPACKE_dge_nancheck 🕵️‍♀️

LAPACKE_dge_trans 🔄

LAPACKE_dgg_nancheck 🕵️‍♀️

LAPACKE_dgg_trans 🔄

LAPACKE_dgt_nancheck 🕵️‍♀️

LAPACKE_dhs_nancheck 🕵️‍♀️

LAPACKE_dhs_trans 🔄

LAPACKE_dpb_nancheck 🕵️‍♀️

LAPACKE_dpb_trans 🔄

LAPACKE_dpf_nancheck 🕵️‍♀️

LAPACKE_dpf_trans 🔄

LAPACKE_dpo_nancheck 🕵️‍♀️

LAPACKE_dpo_trans 🔄

LAPACKE_dpp_nancheck 🕵️‍♀️

LAPACKE_dpp_trans 🔄

LAPACKE_dpt_nancheck 🕵️‍♀️

LAPACKE_dsb_nancheck 🕵️‍♀️

LAPACKE_dsb_trans 🔄

LAPACKE_dsp_nancheck 💅

LAPACKE_dsp_trans 🦋

LAPACKE_dst_nancheck 🎀

LAPACKE_dsy_nancheck 💖

LAPACKE_dsy_trans 🌸

LAPACKE_dtb_nancheck 🧚

LAPACKE_dtb_trans ⭐

LAPACKE_dtf_nancheck 🔥