uncsd2by1(3)

📦

version 3.12.1 · 9 versions

3.12.1 · arch rolling (latest)
3.12.0 · opensuse-leap 16.0
3.12.1 · ubuntu stonking
3.12.1 · ubuntu questing
3.12.0 · ubuntu noble
3.12.0 · ubuntu noble
3.12.0 · centos-stream 10, fedora 43, fedora 44
3.12.1 · ubuntu resolute
3.12.1 · debian trixie

💅 uncsd2by1(3) — Library Functions Manual

okay so this is uncsd2by1, straight out of the Library Functions Manual, section 3. It's the umbrella page for the whole {un,or}csd2by1 family — the CS-decomposition girlies 💖 — and yes, it's a long one, so buckle up.

📛 NAME

uncsd2by1 — {un,or}csd2by1: ??

(no cap, the original literally says ?? — we keep it real here 🫶)

✨ SYNOPSIS

Functions

The four subroutine besties, verbatim, no edits, character for character:

subroutine cuncsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21,
    ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork,
    lrwork, iwork, info)
    CUNCSD2BY1

subroutine dorcsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21,
    ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork,
    info)
    DORCSD2BY1

subroutine sorcsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21,
    ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, iwork,
    info)
    SORCSD2BY1

subroutine zuncsd2by1 (jobu1, jobu2, jobv1t, m, p, q, x11, ldx11, x21,
    ldx21, theta, u1, ldu1, u2, ldu2, v1t, ldv1t, work, lwork, rwork,
    lrwork, iwork, info)
    ZUNCSD2BY1

🦋 Detailed Description

Yeah bestie, this is where the actual docs live. Scroll down, it's giving long. 💀

🔥 Function Documentation

`cuncsd2by1`

subroutine cuncsd2by1 (character jobu1, character jobu2, character jobv1t,
    integer m, integer p, integer q, complex, dimension(ldx11,*) x11,
    integer ldx11, complex, dimension(ldx21,*) x21, integer ldx21, real,
    dimension(*) theta, complex, dimension(ldu1,*) u1, integer ldu1,
    complex, dimension(ldu2,*) u2, integer ldu2, complex, dimension(ldv1t,*)
    v1t, integer ldv1t, complex, dimension(*) work, integer lwork, real,
    dimension(*) rwork, integer lrwork, integer, dimension(*) iwork, integer
    info)
    CUNCSD2BY1

Purpose

okay so CUNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns — and this X has already been partitioned into a 2-by-1 block structure. It's giving this exact picture:

                               [  I1 0  0 ]
                               [  0  C  0 ]
         [ X11 ]   [ U1 |    ] [  0  0  0 ]
     X = [-----] = [---------] [----------] V1**T .
         [ X21 ]   [    | U2 ] [  0  0  0 ]
                               [  0  S  0 ]
                               [  0  0  I2]

X11 is P-by-Q, periodt. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, where R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0). Iconic. 👑

Parameters

JOBU1 — JOBU1 is CHARACTER. = 'Y': U1 is computed; otherwise: U1 is not computed. 🙈
JOBU2 — JOBU2 is CHARACTER. = 'Y': U2 is computed; otherwise: U2 is not computed. 🙈
JOBV1T — JOBV1T is CHARACTER. = 'Y': V1T is computed; otherwise: V1T is not computed. 🙈
M — M is INTEGER. The number of rows in X.
P — P is INTEGER. The number of rows in X11. 0 <= P <= M.
Q — Q is INTEGER. The number of columns in X11 and X21. 0 <= Q <= M.
X11 — X11 is COMPLEX array, dimension (LDX11,Q). On entry, part of the unitary matrix whose CSD is desired.
LDX11 — LDX11 is INTEGER. The leading dimension of X11. LDX11 >= MAX(1,P).
X21 — X21 is COMPLEX array, dimension (LDX21,Q). On entry, part of the unitary matrix whose CSD is desired.
LDX21 — LDX21 is INTEGER. The leading dimension of X21. LDX21 >= MAX(1,M-P).
THETA — THETA is REAL array, dimension (R), in which R = MIN(P,M-P,Q,M-Q). C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) ). trig girlies rise 🌸
U1 — U1 is COMPLEX array, dimension (P). If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1.
LDU1 — LDU1 is INTEGER. The leading dimension of U1. If JOBU1 = 'Y', LDU1 >= MAX(1,P).
U2 — U2 is COMPLEX array, dimension (M-P). If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary matrix U2.
LDU2 — LDU2 is INTEGER. The leading dimension of U2. If JOBU2 = 'Y', LDU2 >= MAX(1,M-P).
V1T — V1T is COMPLEX array, dimension (Q). If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary matrix V1**T.
LDV1T — LDV1T is INTEGER. The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >= MAX(1,Q).
WORK — WORK is COMPLEX array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK.
LWORK — LWORK is INTEGER. The dimension of the array WORK.

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK and RWORK arrays, returns this value as the first entry of the WORK and RWORK array, respectively, and no error message related to LWORK or LRWORK is issued by XERBLA. 🧚 (the ol' -1 trick, iykyk)

RWORK — RWORK is REAL array, dimension (MAX(1,LRWORK)). On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.

If INFO > 0 on exit, RWORK(2:R) contains the values PHI(1), ..., PHI(R-1) that, together with THETA(1), ..., THETA(R), define the matrix in intermediate bidiagonal-block form remaining after nonconvergence. INFO specifies the number of nonzero PHI's. 😭

LRWORK — LRWORK is INTEGER. The dimension of the array RWORK.

If LRWORK=-1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK and RWORK arrays, returns this value as the first entry of the WORK and RWORK array, respectively, and no error message related to LWORK or LRWORK is issued by XERBLA.

IWORK — IWORK is INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q)).
INFO — INFO is INTEGER. = 0: successful exit. < 0: if INFO = -i, the i-th argument had an illegal value. > 0: CBBCSD did not converge. See the description of WORK above for details.

References

[1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009. 📚

Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 253 of file cuncsd2by1.f.

`dorcsd2by1`

subroutine dorcsd2by1 (character jobu1, character jobu2, character jobv1t,
    integer m, integer p, integer q, double precision, dimension(ldx11,*)
    x11, integer ldx11, double precision, dimension(ldx21,*) x21, integer
    ldx21, double precision, dimension(*) theta, double precision,
    dimension(ldu1,*) u1, integer ldu1, double precision, dimension(ldu2,*)
    u2, integer ldu2, double precision, dimension(ldv1t,*) v1t, integer
    ldv1t, double precision, dimension(*) work, integer lwork, integer,
    dimension(*) iwork, integer info)
    DORCSD2BY1

Purpose

DORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure:

                               [  I1 0  0 ]
                               [  0  C  0 ]
         [ X11 ]   [ U1 |    ] [  0  0  0 ]
     X = [-----] = [---------] [----------] V1**T .
         [ X21 ]   [    | U2 ] [  0  0  0 ]
                               [  0  S  0 ]
                               [  0  0  I2]

X11 is P-by-Q. The orthogonal matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

Parameters

JOBU1 — JOBU1 is CHARACTER. = 'Y': U1 is computed; otherwise: U1 is not computed.
JOBU2 — JOBU2 is CHARACTER. = 'Y': U2 is computed; otherwise: U2 is not computed.
JOBV1T — JOBV1T is CHARACTER. = 'Y': V1T is computed; otherwise: V1T is not computed.
M — M is INTEGER. The number of rows in X.
P — P is INTEGER. The number of rows in X11. 0 <= P <= M.
Q — Q is INTEGER. The number of columns in X11 and X21. 0 <= Q <= M.
X11 — X11 is DOUBLE PRECISION array, dimension (LDX11,Q). On entry, part of the orthogonal matrix whose CSD is desired.
LDX11 — LDX11 is INTEGER. The leading dimension of X11. LDX11 >= MAX(1,P).
X21 — X21 is DOUBLE PRECISION array, dimension (LDX21,Q). On entry, part of the orthogonal matrix whose CSD is desired.
LDX21 — LDX21 is INTEGER. The leading dimension of X21. LDX21 >= MAX(1,M-P).
THETA — THETA is DOUBLE PRECISION array, dimension (R), in which R = MIN(P,M-P,Q,M-Q). C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) ).
U1

(...and that's literally exactly where this chunk of the page runs out — the U1 writeup picks right back up in the next part 🫶)

...and now we're in the outputs, bestie — the places where this thing actually drops the goods. 💅

U1 — DOUBLE PRECISION array, dimension (P). If JOBU1 = 'Y', then U1 contains the P-by-P orthogonal matrix U1. If you didn't ask for it, she's simply not computed — no freebies.
LDU1 — INTEGER. The leading dimension of U1. If JOBU1 = 'Y', you need LDU1 >= MAX(1,P).
U2 — DOUBLE PRECISION array, dimension (M-P). If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) orthogonal matrix U2. Same deal: 'Y' or she stays uncomputed. 🙈
LDU2 — INTEGER. The leading dimension of U2. If JOBU2 = 'Y', then LDU2 >= MAX(1,M-P).
V1T — DOUBLE PRECISION array, dimension (Q). If JOBV1T = 'Y', V1T contains the Q-by-Q matrix orthogonal matrix V1**T. Yes, the transpose is baked right into the name, she's literally telling you. 💅
LDV1T — INTEGER. The leading dimension of V1T. If JOBV1T = 'Y', then LDV1T >= MAX(1,Q).
WORK — DOUBLE PRECISION array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. And here's the tea: if INFO > 0 on exit, WORK(2:R) contains the values PHI(1), ..., PHI(R-1) that, together with THETA(1), ..., THETA(R), define the matrix in intermediate bidiagonal-block form remaining after nonconvergence. INFO specifies the number of nonzero PHI's. So even when she doesn't converge, she leaves you a whole forensic trail. 🔥
LWORK — INTEGER. The dimension of the array WORK.

If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the work array, and no error message related to LWORK is issued by XERBLA. Nice — you can just ask her how much room she needs, and she won't yell at you for it. 🎀

IWORK — INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q)). That's the exact dimension, copy it character for character, don't get cute.
INFO — INTEGER.
- = 0: successful exit. we love her, we stan. 👑
- < 0: if INFO = -i, the i-th argument had an illegal value.
- > 0: DBBCSD did not converge. See the description of WORK above for details.

Fr fr, that INFO > 0 case is not a vibe — nonconvergence is real, and the leftover PHI values in WORK are your only clue about what survived. Read the WORK note again if you skipped it. 😭

📚 References

[1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009.

🫶 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 230 of file dorcsd2by1.f.

🌸 subroutine `sorcsd2by1` — the single-precision twin

She's the REAL version, and she's iconic in her own right:

subroutine sorcsd2by1 (character jobu1, character jobu2, character jobv1t,
    integer m, integer p, integer q, real, dimension(ldx11,*) x11, integer
    ldx11, real, dimension(ldx21,*) x21, integer ldx21, real, dimension(*)
    theta, real, dimension(ldu1,*) u1, integer ldu1, real, dimension(ldu2,*)
    u2, integer ldu2, real, dimension(ldv1t,*) v1t, integer ldv1t, real,
    dimension(*) work, integer lwork, integer, dimension(*) iwork, integer
    info)

✨ SORCSD2BY1

Purpose

Okay so picture this — SORCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure:

                               [  I1 0  0 ]
                               [  0  C  0 ]
         [ X11 ]   [ U1 |    ] [  0  0  0 ]
     X = [-----] = [---------] [----------] V1**T .
         [ X21 ]   [    | U2 ] [  0  0  0 ]
                               [  0  S  0 ]
                               [  0  0  I2]

Literally the same decomposition as the double-precision one, just in single precision. 💜

🎀 Parameters

JOBU1 — CHARACTER.
- = 'Y': U1 is computed;
- otherwise: U1 is not computed.
JOBU2 — CHARACTER.
- = 'Y': U2 is computed;
- otherwise: U2 is not computed.
JOBV1T — CHARACTER.
- = 'Y': V1T is computed;
- otherwise: V1T is not computed.
M — INTEGER. The number of rows in X.
P — INTEGER. The number of rows in X11. 0 <= P <= M.
Q — INTEGER. The number of columns in X11 and X21. 0 <= Q <= M.
X11 — REAL array, dimension (LDX11,Q). On entry, part of the orthogonal matrix whose CSD is desired.
LDX11 — INTEGER. The leading dimension of X11. LDX11 >= MAX(1,P).
X21 — REAL array, dimension (LDX21,Q). On entry, part of the orthogonal matrix whose CSD is desired.
LDX21 — INTEGER. The leading dimension of X21. LDX21 >= MAX(1,M-P).
THETA — REAL array, dimension (R), in which R = MIN(P,M-P,Q,M-Q). C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) ). The angles go in, the cosines and sines come out — it's giving trigonometry main character energy. 📐✨
U1 — REAL array, dimension (P). If JOBU1 = 'Y', U1 contains the P-by-P orthogonal matrix U1.
LDU1 — INTEGER. The leading dimension of U1. If JOBU1 = 'Y', LDU1 >= MAX(1,P).
U2 — REAL array, dimension (M-P). If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) orthogonal matrix U2.
LDU2 — INTEGER. The leading dimension of U2. If JOBU2 = 'Y', LDU2 >= MAX(1,M-P).
V1T — REAL array, dimension (Q). If JOBV1T = 'Y', V1T contains the Q-by-Q matrix orthogonal matrix V1**T.
LDV1T — INTEGER. The leading dimension of V1T. If JOBV1T = 'Y', LDV1T >= MAX(1,Q).
WORK — REAL array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. If INFO > 0 on exit, WORK(2:R) contains the values PHI(1), ..., PHI(R-1) that, together with THETA(1), ..., THETA(R), define the matrix in intermediate bidiagonal-block form remaining after nonconvergence. INFO specifies the number of nonzero PHI's.
LWORK — INTEGER. The dimension of the array WORK.

IWORK — INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q)).
INFO — INTEGER.
- = 0: successful exit.
- < 0: if INFO = -i, the i-th argument had an illegal value.
- > 0: SBBCSD did not converge. See the description of WORK above for details.

Notice the difference from the double-precision page: here it's SBBCSD that failed to converge, not DBBCSD. Type the right one, iykyk. 👀

📚 References

[1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009.

🫶 Author

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line 230 of file sorcsd2by1.f.

🦋 subroutine `zuncsd2by1` — now with complex*16 and everything

And here's the complex*16 one, with a whole extra RWORK situation. She's doing the most and honestly? deserved. 💅

subroutine zuncsd2by1 (character jobu1, character jobu2, character jobv1t,
    integer m, integer p, integer q, complex*16, dimension(ldx11,*) x11,
    integer ldx11, complex*16, dimension(ldx21,*) x21, integer ldx21, double
    precision, dimension(*) theta, complex*16, dimension(ldu1,*) u1, integer
    ldu1, complex*16, dimension(ldu2,*) u2, integer ldu2, complex*16,
    dimension(ldv1t,*) v1t, integer ldv1t, complex*16, dimension(*) work,
    integer lwork, double precision, dimension(*) rwork, integer lrwork,
    integer, dimension(*) iwork, integer info)

✨ ZUNCSD2BY1

Purpose

ZUNCSD2BY1 computes the CS decomposition of an M-by-Q matrix X with orthonormal columns that has been partitioned into a 2-by-1 block structure:

                               [  I1 0  0 ]
                               [  0  C  0 ]
         [ X11 ]   [ U1 |    ] [  0  0  0 ]
     X = [-----] = [---------] [----------] V1**T .
         [ X21 ]   [    | U2 ] [  0  0  0 ]
                               [  0  S  0 ]
                               [  0  0  I2]

X11 is P-by-Q. The unitary matrices U1, U2, and V1 are P-by-P, (M-P)-by-(M-P), and Q-by-Q, respectively. C and S are R-by-R nonnegative diagonal matrices satisfying C^2 + S^2 = I, in which R = MIN(P,M-P,Q,M-Q). I1 is a K1-by-K1 identity matrix and I2 is a K2-by-K2 identity matrix, where K1 = MAX(Q+P-M,0), K2 = MAX(Q-P,0).

Key difference, don't miss it: U1, U2, V1 are unitary here, not orthogonal — because complex. 🌈

🎀 Parameters

JOBU1 — CHARACTER.
- = 'Y': U1 is computed;
- otherwise: U1 is not computed.
JOBU2 — CHARACTER.
- = 'Y': U2 is computed;
- otherwise: U2 is not computed.
JOBV1T — CHARACTER.
- = 'Y': V1T is computed;
- otherwise: V1T is not computed.
M — INTEGER. The number of rows in X.
P — INTEGER. The number of rows in X11. 0 <= P <= M.
Q — INTEGER. The number of columns in X11 and X21. 0 <= Q <= M.
X11
X11 — a COMPLEX*16 array, dimension (LDX11,Q). On entry, this is part of the unitary matrix whose CSD you're after, bestie. 💅
LDX11 — INTEGER. The leading dimension of X11. Gotta obey LDX11 >= MAX(1,P). No cap. ✨
X21 — a COMPLEX*16 array, dimension (LDX21,Q). On entry, this is part of the unitary matrix whose CSD is desired. 🦋
LDX21 — INTEGER. The leading dimension of X21. It must satisfy LDX21 >= MAX(1,M-P). 🔥
THETA — a DOUBLE PRECISION array, dimension (R), where R = MIN(P,M-P,Q,M-Q). And then: C = DIAG( COS(THETA(1)), ... , COS(THETA(R)) ) and S = DIAG( SIN(THETA(1)), ... , SIN(THETA(R)) ). That's the whole vibe. 🎀
U1 — a COMPLEX*16 array, dimension (P). If JOBU1 = 'Y', U1 contains the P-by-P unitary matrix U1. 👑
LDU1 — INTEGER. The leading dimension of U1. If JOBU1 = 'Y', then LDU1 >= MAX(1,P). 💖
U2 — a COMPLEX*16 array, dimension (M-P). If JOBU2 = 'Y', U2 contains the (M-P)-by-(M-P) unitary matrix U2. 🌸
LDU2 — INTEGER. The leading dimension of U2. If JOBU2 = 'Y', then LDU2 >= MAX(1,M-P). ⭐
V1T — a COMPLEX*16 array, dimension (Q). If JOBV1T = 'Y', V1T contains the Q-by-Q matrix unitary matrix V1**T — yes, the source says “matrix unitary matrix,” and honestly? Iconic. 💅
LDV1T — INTEGER. The leading dimension of V1T. If JOBV1T = 'Y', then LDV1T >= MAX(1,Q). 🫶
WORK — a COMPLEX*16 array, dimension (MAX(1,LWORK)). On exit, if INFO = 0, WORK(1) returns the optimal LWORK. ✨
LWORK — INTEGER. The dimension of the array WORK.

RWORK — a DOUBLE PRECISION array, dimension (MAX(1,LRWORK)). On exit, if INFO = 0, RWORK(1) returns the optimal LRWORK.

LRWORK — INTEGER. The dimension of the array RWORK.

IWORK — INTEGER array, dimension (M-MIN(P,M-P,Q,M-Q)). 🧚
INFO — INTEGER.

= 0: successful exit. Slay. ✅

< 0: if INFO = -i, the i-th argument had an illegal value. 💀

> 0: ZBBCSD did not converge. See the description of WORK above for details. 🚨

📚 References

[1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009. 📖

👑 Author

Univ. of Tennessee
Univ. of California Berkeley
Univ. of Colorado Denver
NAG Ltd.

Definition at line 252 of file zuncsd2by1.f. 🎯

🤖 Author

Generated automatically by Doxygen for LAPACK from the source code. ✨

Source/version sign-off, bestie: this iconic page is from LAPACK, Version 3.12.0 — and the footer doesn't show a date, so we're not inventing one. 💖🫶

📦 where this page comes from

arch rolling: lapack-doc 3.12.1-2 · custom
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash-1017 on 2026-11-04: a language model's rewrite of the original, under its terms

uncsd2by1(3)

💅 uncsd2by1(3) — Library Functions Manual

📛 NAME

✨ SYNOPSIS

Functions

🦋 Detailed Description

🔥 Function Documentation

cuncsd2by1

Purpose

Parameters

References

Author

dorcsd2by1

Purpose

Parameters

📚 References

🫶 Author

🌸 subroutine sorcsd2by1 — the single-precision twin

✨ SORCSD2BY1

Purpose

🎀 Parameters

📚 References

🫶 Author

🦋 subroutine zuncsd2by1 — now with complex*16 and everything

✨ ZUNCSD2BY1

Purpose

🎀 Parameters

📚 References

👑 Author

🤖 Author

`cuncsd2by1`

`dorcsd2by1`

🌸 subroutine `sorcsd2by1` — the single-precision twin

🦋 subroutine `zuncsd2by1` — now with complex*16 and everything