tpttf(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

okay bestie, this is tpttf(3) from the Library Functions Manual, and it's giving triangular matrix, packed (tp) to RFP (tf) realness. no cap. 💅✨

✨ NAME ✨

tpttf — tpttf: triangular matrix, packed (tp) to RFP (tf).

🦋 SYNOPSIS 🦋

🧚 Functions 🧚

subroutine ctpttf (transr, uplo, n, ap, arf, info) — CTPTTF copies a triangular matrix from the standard packed format (TP) to the rectangular full packed format (TF). 💖
subroutine dtpttf (transr, uplo, n, ap, arf, info) — DTPTTF copies a triangular matrix from the standard packed format (TP) to the rectangular full packed format (TF). ✨
subroutine stpttf (transr, uplo, n, ap, arf, info) — STPTTF copies a triangular matrix from the standard packed format (TP) to the rectangular full packed format (TF). 🌸
subroutine ztpttf (transr, uplo, n, ap, arf, info) — ZTPTTF copies a triangular matrix from the standard packed format (TP) to the rectangular full packed format (TF). ⭐

🌸 Detailed Description 🌸

okay so the detailed description is literally the function docs below. keep scrolling, bestie. 🫶

💅 Function Documentation 💅

🌟 subroutine ctpttf 🌟

subroutine ctpttf (character transr, character uplo, integer n, complex, dimension( 0: * ) ap, complex, dimension( 0: * ) arf, integer info)

💖 Purpose 💖

CTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

🎀 Parameters 🎀

TRANSR — CHARACTER*1. This is the format selector:
- = 'N': ARF in Normal format is wanted;
- = 'C': ARF in Conjugate-transpose format is wanted.
UPLO — CHARACTER*1:
- = 'U': A is upper triangular;
- = 'L': A is lower triangular.
N — INTEGER. The order of the matrix A. N >= 0.
AP — COMPLEX array, dimension ( N*(N+1)/2 ). On entry, this is the upper or lower triangular matrix A, packed columnwise in a linear array. The j-th column of A is stored in AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
ARF — COMPLEX array, dimension ( N*(N+1)/2 ). On exit, the upper or lower triangular matrix A stored in RFP format. For a further discussion see Notes below.
INFO — INTEGER:
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value

👑 Author 👑

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

🧚 Further Details: 🧚

the diagram tea is real, and it is exact. 🌈

!>
!>  We first consider Standard Packed Format when N is even.
!>  We give an example where N = 6.
!>
!>      AP is Upper             AP is Lower
!>
!>   00 01 02 03 04 05       00
!>      11 12 13 14 15       10 11
!>         22 23 24 25       20 21 22
!>            33 34 35       30 31 32 33
!>               44 45       40 41 42 43 44
!>                  55       50 51 52 53 54 55
!>
!>
!>  Let TRANSR = 'N'. RFP holds AP as follows:
!>  For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
!>  three columns of AP upper. The lower triangle A(4:6,0:2) consists of
!>  conjugate-transpose of the first three columns of AP upper.
!>  For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
!>  three columns of AP lower. The upper triangle A(0:2,0:2) consists of
!>  conjugate-transpose of the last three columns of AP lower.
!>  To denote conjugate we place -- above the element. This covers the
!>  case N even and TRANSR = 'N'.
!>
!>         RFP A                   RFP A
!>
!>                                -- -- --
!>        03 04 05                33 43 53
!>                                   -- --
!>        13 14 15                00 44 54
!>                                      --
!>        23 24 25                10 11 55
!>
!>        33 34 35                20 21 22
!>        --
!>        00 44 45                30 31 32
!>        -- --
!>        01 11 55                40 41 42
!>        -- -- --
!>        02 12 22                50 51 52
!>
!>  Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
!>  transpose of RFP A above. One therefore gets:
!>
!>
!>           RFP A                   RFP A
!>
!>     -- -- -- --                -- -- -- -- -- --
!>     03 13 23 33 00 01 02    33 00 10 20 30 40 50
!>     -- -- -- -- --                -- -- -- -- --
!>     04 14 24 34 44 11 12    43 44 11 21 31 41 51
!>     -- -- -- -- -- --                -- -- -- --
!>     05 15 25 35 45 55 22    53 54 55 22 32 42 52
!>
!>
!>  We next  consider Standard Packed Format when N is odd.
!>  We give an example where N = 5.
!>
!>     AP is Upper                 AP is Lower
!>
!>   00 01 02 03 04              00
!>      11 12 13 14              10 11
!>         22 23 24              20 21 22
!>            33 34              30 31 32 33
!>               44              40 41 42 43 44
!>
!>
!>  Let TRANSR = 'N'. RFP holds AP as follows:
!>  For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
!>  three columns of AP upper. The lower triangle A(3:4,0:1) consists of
!>  conjugate-transpose of the first two   columns of AP upper.
!>  For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
!>  three columns of AP lower. The upper triangle A(0:1,1:2) consists of
!>  conjugate-transpose of the last two   columns of AP lower.
!>  To denote conjugate we place -- above the element. This covers the
!>  case N odd  and TRANSR = 'N'.
!>
!>         RFP A                   RFP A
!>
!>                                   -- --
!>        02 03 04                00 33 43
!>                                      --
!>        12 13 14                10 11 44
!>
!>        22 23 24                20 21 22
!>        --
!>        00 33 34                30 31 32
!>        -- --
!>        01 11 44                40 41 42
!>
!>  Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-
!>  transpose of RFP A above. One therefore gets:
!>
!>
!>           RFP A                   RFP A
!>
!>     -- -- --                   -- -- -- -- -- --
!>     02 12 22 00 01             00 10 20 30 40 50
!>     -- -- -- --                   -- -- -- -- --
!>     03 13 23 33 11             33 11 21 31 41 51
!>     -- -- -- -- --                   -- -- -- --
!>     04 14 24 34 44             43 44 22 32 42 52
!>

Definition at line 206 of file ctpttf.f.

✨ subroutine dtpttf ✨

subroutine dtpttf (character transr, character uplo, integer n, double precision, dimension( 0: * ) ap, double precision, dimension( 0: * ) arf, integer info)

💖 Purpose 💖

DTPTTF copies a triangular matrix A from standard packed format (TP) to rectangular full packed format (TF).

🎀 Parameters 🎀

TRANSR — CHARACTER*1. Format selector, but note the letter:
- = 'N': ARF in Normal format is wanted;
- = 'T': ARF in Conjugate-transpose format is wanted.
UPLO — CHARACTER*1:
- = 'U': A is upper triangular;
- = 'L': A is lower triangular.
N — INTEGER. The order of the matrix A. N >= 0.
AP — DOUBLE PRECISION array, dimension ( N*(N+1)/2 ). On entry, this is the upper or lower triangular matrix A, packed columnwise in a linear array. The j-th column of A is stored in AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
ARF — DOUBLE PRECISION array, dimension ( N*(N+1)/2 ). On exit, the upper or lower triangular matrix A stored in RFP format. For a further discussion see Notes below.
INFO — INTEGER:
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value

👑 Author 👑

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

🌸 Further Details 🌸

💅 Further Details — the RFP format lore

ok so here's the whole picture, and honestly it's giving "math girlie explaining her grid system" energy. First we consider Rectangular Full Packed (RFP) Format when N is even, with the example N = 6:

!>      AP is Upper             AP is Lower
!>
!>   00 01 02 03 04 05       00
!>      11 12 13 14 15       10 11
!>         22 23 24 25       20 21 22
!>            33 34 35       30 31 32 33
!>               44 45       40 41 42 43 44
!>                  55       50 51 52 53 54 55
!>
!>
!>  Let TRANSR = 'N'. RFP holds AP as follows:
!>  For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
!>  three columns of AP upper. The lower triangle A(4:6,0:2) consists of
!>  the transpose of the first three columns of AP upper.
!>  For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
!>  three columns of AP lower. The upper triangle A(0:2,0:2) consists of
!>  the transpose of the last three columns of AP lower.
!>  This covers the case N even and TRANSR = 'N'.
!>
!>         RFP A                   RFP A
!>
!>        03 04 05                33 43 53
!>        13 14 15                00 44 54
!>        23 24 25                10 11 55
!>        33 34 35                20 21 22
!>        00 44 45                30 31 32
!>        01 11 55                40 41 42
!>        02 12 22                50 51 52
!>
!>  Now let TRANSR = 'T'. RFP A in both UPLO cases is just the
!>  transpose of RFP A above. One therefore gets:
!>
!>
!>           RFP A                   RFP A
!>
!>     03 13 23 33 00 01 02    33 00 10 20 30 40 50
!>     04 14 24 34 44 11 12    43 44 11 21 31 41 51
!>     05 15 25 35 45 55 22    53 54 55 22 32 42 52

Then we consider Rectangular Full Packed (RFP) Format when N is odd, with the example N = 5 — yes, the parity switch-up is a whole thing, bestie:

!>     AP is Upper                 AP is Lower
!>
!>   00 01 02 03 04              00
!>      11 12 13 14              10 11
!>         22 23 24              20 21 22
!>            33 34              30 31 32 33
!>               44              40 41 42 43 44
!>
!>
!>  Let TRANSR = 'N'. RFP holds AP as follows:
!>  For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
!>  three columns of AP upper. The lower triangle A(3:4,0:1) consists of
!>  the transpose of the first two columns of AP upper.
!>  For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
!>  three columns of AP lower. The upper triangle A(0:1,1:2) consists of
!>  the transpose of the last two columns of AP lower.
!>  This covers the case N odd and TRANSR = 'N'.
!>
!>         RFP A                   RFP A
!>
!>        02 03 04                00 33 43
!>        12 13 14                10 11 44
!>        22 23 24                20 21 22
!>        00 33 34                30 31 32
!>        01 11 44                40 41 42
!>
!>  Now let TRANSR = 'T'. RFP A in both UPLO cases is just the
!>  transpose of RFP A above. One therefore gets:
!>
!>           RFP A                   RFP A
!>
!>     02 12 22 00 01             00 10 20 30 40 50
!>     03 13 23 33 11             33 11 21 31 41 51
!>     04 14 24 34 44             43 44 22 32 42 52

🌸 `stpttf` — the single-precision real one

subroutine stpttf (character transr, character uplo, integer n, real,
    dimension( 0: * ) ap, real, dimension( 0: * ) arf, integer info)

STPTTF copies a triangular matrix from the standard packed format (TP) to the rectangular full packed format (TF). Same energy as dtpttf, just with REAL numbers instead of DOUBLE PRECISION ones — she's the lowkey twin 💫

Purpose

!>
!> STPTTF copies a triangular matrix A from standard packed format (TP)
!> to rectangular full packed format (TF).
!>

Parameters

TRANSR is CHARACTER*1
- = 'N': ARF in Normal format is wanted;
- = 'T': ARF in Conjugate-transpose format is wanted.
UPLO is CHARACTER*1
- = 'U': A is upper triangular;
- = 'L': A is lower triangular.
N is INTEGER — the order of the matrix A. N >= 0. (no cap, just vibes ✨)
AP is REAL array, dimension ( N*(N+1)/2 ) On entry, the upper or lower triangular matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
ARF is REAL array, dimension ( N*(N+1)/2 ) On exit, the upper or lower triangular matrix A stored in RFP format. For a further discussion see Notes below. 👀
INFO is INTEGER
- = 0: successful exit (we love a win 🎀)
- < 0: if INFO = -i, the i-th argument had an illegal value

Author

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

Further Details

Same tea as above, and no I'm not skipping it — every bit of it matters. First up, the N even case, example N = 6:

!>      AP is Upper             AP is Lower
!>
!>   00 01 02 03 04 05       00
!>      11 12 13 14 15       10 11
!>         22 23 24 25       20 21 22
!>            33 34 35       30 31 32 33
!>               44 45       40 41 42 43 44
!>                  55       50 51 52 53 54 55
!>
!>
!>  Let TRANSR = 'N'. RFP holds AP as follows:
!>  For UPLO = 'U' the upper trapezoid A(0:5,0:2) consists of the last
!>  three columns of AP upper. The lower triangle A(4:6,0:2) consists of
!>  the transpose of the first three columns of AP upper.
!>  For UPLO = 'L' the lower trapezoid A(1:6,0:2) consists of the first
!>  three columns of AP lower. The upper triangle A(0:2,0:2) consists of
!>  the transpose of the last three columns of AP lower.
!>  This covers the case N even and TRANSR = 'N'.
!>
!>         RFP A                   RFP A
!>
!>        03 04 05                33 43 53
!>        13 14 15                00 44 54
!>        23 24 25                10 11 55
!>        33 34 35                20 21 22
!>        00 44 45                30 31 32
!>        01 11 55                40 41 42
!>        02 12 22                50 51 52
!>
!>  Now let TRANSR = 'T'. RFP A in both UPLO cases is just the
!>  transpose of RFP A above. One therefore gets:
!>
!>
!>           RFP A                   RFP A
!>
!>     03 13 23 33 00 01 02    33 00 10 20 30 40 50
!>     04 14 24 34 44 11 12    43 44 11 21 31 41 51
!>     05 15 25 35 45 55 22    53 54 55 22 32 42 52

Then the N odd case, example N = 5:

!>     AP is Upper                 AP is Lower
!>
!>   00 01 02 03 04              00
!>      11 12 13 14              10 11
!>         22 23 24              20 21 22
!>            33 34              30 31 32 33
!>               44              40 41 42 43 44
!>
!>
!>  Let TRANSR = 'N'. RFP holds AP as follows:
!>  For UPLO = 'U' the upper trapezoid A(0:4,0:2) consists of the last
!>  three columns of AP upper. The lower triangle A(3:4,0:1) consists of
!>  the transpose of the first two columns of AP upper.
!>  For UPLO = 'L' the lower trapezoid A(0:4,0:2) consists of the first
!>  three columns of AP lower. The upper triangle A(0:1,1:2) consists of
!>  the transpose of the last two columns of AP lower.
!>  This covers the case N odd and TRANSR = 'N'.
!>
!>         RFP A                   RFP A
!>
!>        02 03 04                00 33 43
!>        12 13 14                10 11 44
!>        22 23 24                20 21 22
!>        00 33 34                30 31 32
!>        01 11 44                40 41 42
!>
!>  Now let TRANSR = 'T'. RFP A in both UPLO cases is just the
!>  transpose of RFP A above. One therefore gets:
!>
!>           RFP A                   RFP A
!>
!>     02 12 22 00 01             00 10 20 30 40 50
!>     03 13 23 33 11             33 11 21 31 41 51
!>     04 14 24 34 44             43 44 22 32 42 52

Definition at line 185 of file stpttf.f.

🦋 `ztpttf` — the big complex `COMPLEX*16` one

subroutine ztpttf (character transr, character uplo, integer n, complex*16,
    dimension( 0: * ) ap, complex*16, dimension( 0: * ) arf, integer info)

ZTPTTF copies a triangular matrix from the standard packed format (TP) to the rectangular full packed format (TF). She's complex, she's double precision, she's the main character of the TPTTF cinematic universe 👑

Purpose

!>
!> ZTPTTF copies a triangular matrix A from standard packed format (TP)
!> to rectangular full packed format (TF).
!>

Parameters

TRANSR is CHARACTER*1
- = 'N': ARF in Normal format is wanted;
- = 'C': ARF in Conjugate-transpose format is wanted. 🫧 (note it's 'C' here, not 'T' — conjugates are built different, fr fr)
UPLO is CHARACTER*1
- = 'U': A is upper triangular;
- = 'L': A is lower triangular.
N is INTEGER — the order of the matrix A. N >= 0.
AP is COMPLEX*16 array, dimension ( N*(N+1)/2 ) On entry, the upper or lower triangular matrix A, packed columnwise in a linear array. The j-th column of A is stored in the array AP as follows:
- if UPLO = 'U', AP(i + (j-1)*j/2) = A(i,j) for 1<=i<=j;
- if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) = A(i,j) for j<=i<=n.
ARF is COMPLEX*16 array, dimension ( N*(N+1)/2 ) On exit, the upper or lower triangular matrix A stored in RFP format. For a further discussion see Notes below. 📝
INFO is INTEGER
- = 0: successful exit
- < 0: if INFO = -i, the i-th argument had an illegal value
INFO — INTEGER, bestie, it's the vibe report at the end 💅
- = 0: successful exit ✨ iconic, flawless, no notes
- < 0: if INFO = -i, the i-th argument had an illegal value 💀 so like, go count your arguments and find the culprit at position i

👑 Author 👑

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

🎀 Further Details 🎀

Okay so buckle up, because this is the part where we explain the actual layout, and honestly? It's giving puzzle. 🧩

We first consider Standard Packed Format when N is even. We give an example where N = 6.

           !>
           !>  We first consider Standard Packed Format when N is even.
           !>  We give an example where N = 6.
           !>
           !>      AP is Upper             AP is Lower
           !>
           !>   00 01 02 03 04 05       00
           !>      11 12 13 14 15       10 11
           !>         22 23 24 25       20 21 22
           !>            33 34 35       30 31 32 33
           !>               44 45       40 41 42 43 44
           !>                  55       50 51 52 53 54 55
           !>

Let TRANSR = 'N'. RFP holds AP as follows fr fr:

For UPLO = 'U', the upper trapezoid A(0:5,0:2) consists of the last three columns of AP upper. The lower triangle A(4:6,0:2) consists of the conjugate-transpose of the first three columns of AP upper.
For UPLO = 'L', the lower trapezoid A(1:6,0:2) consists of the first three columns of AP lower. The upper triangle A(0:2,0:2) consists of the conjugate-transpose of the last three columns of AP lower.

To denote conjugate we place -- above the element. This covers the case N even and TRANSR = 'N' 🦋

           !>
           !>         RFP A                   RFP A
           !>
           !>                                -- -- --
           !>        03 04 05                33 43 53
           !>                                   -- --
           !>        13 14 15                00 44 54
           !>                                      --
           !>        23 24 25                10 11 55
           !>
           !>        33 34 35                20 21 22
           !>        --
           !>        00 44 45                30 31 32
           !>        -- --
           !>        01 11 55                40 41 42
           !>        -- -- --
           !>        02 12 22                50 51 52
           !>

Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-transpose of RFP A above. One therefore gets:

           !>
           !>           RFP A                   RFP A
           !>
           !>     -- -- -- --                -- -- -- -- -- --
           !>     03 13 23 33 00 01 02    33 00 10 20 30 40 50
           !>     -- -- -- -- --                -- -- -- -- --
           !>     04 14 24 34 44 11 12    43 44 11 21 31 41 51
           !>     -- -- -- -- -- --                -- -- -- --
           !>     05 15 25 35 45 55 22    53 54 55 22 32 42 52
           !>

We next consider Standard Packed Format when N is odd. We give an example where N = 5. (Yes, odd numbers get their own whole section. She's different. 💅)

           !>
           !>  We next  consider Standard Packed Format when N is odd.
           !>  We give an example where N = 5.
           !>
           !>     AP is Upper                 AP is Lower
           !>
           !>   00 01 02 03 04              00
           !>      11 12 13 14              10 11
           !>         22 23 24              20 21 22
           !>            33 34              30 31 32 33
           !>               44              40 41 42 43 44
           !>

Let TRANSR = 'N'. RFP holds AP as follows:

For UPLO = 'U', the upper trapezoid A(0:4,0:2) consists of the last three columns of AP upper. The lower triangle A(3:4,0:1) consists of the conjugate-transpose of the first two columns of AP upper.
For UPLO = 'L', the lower trapezoid A(0:4,0:2) consists of the first three columns of AP lower. The upper triangle A(0:1,1:2) consists of the conjugate-transpose of the last two columns of AP lower.

To denote conjugate we place -- above the element. This covers the case N odd and TRANSR = 'N' 🌈

           !>
           !>         RFP A                   RFP A
           !>
           !>                                   -- --
           !>        02 03 04                00 33 43
           !>                                      --
           !>        12 13 14                10 11 44
           !>
           !>        22 23 24                20 21 22
           !>        --
           !>        00 33 34                30 31 32
           !>        -- --
           !>        01 11 44                40 41 42
           !>

Now let TRANSR = 'C'. RFP A in both UPLO cases is just the conjugate-transpose of RFP A above. One therefore gets:

           !>
           !>           RFP A                   RFP A
           !>
           !>     -- -- --                   -- -- -- -- -- --
           !>     02 12 22 00 01             00 10 20 30 40 50
           !>     -- -- -- --                   -- -- -- -- --
           !>     03 13 23 33 11             33 11 21 31 41 51
           !>     -- -- -- -- --                   -- -- -- --
           !>     04 14 24 34 44             43 44 22 32 42 52
           !>

📍 Definition 📍

Definition at line 206 of file ztpttf.f.

💜 Author 💜

Generated automatically by Doxygen for LAPACK from the source code.

And that's the whole page, bestie! 🫶 This one's LAPACK, Version 3.12.0, page tpttf(3) — and the date column is literally just vibes and empty space, so don't come for me about it 💀✨ Go forth and pack those triangles. 🎀

📦 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

tpttf(3)

✨ NAME ✨

🦋 SYNOPSIS 🦋

🧚 Functions 🧚

🌸 Detailed Description 🌸

💅 Function Documentation 💅

🌟 subroutine ctpttf 🌟

💖 Purpose 💖

🎀 Parameters 🎀

👑 Author 👑

🧚 Further Details: 🧚

✨ subroutine dtpttf ✨

💖 Purpose 💖

🎀 Parameters 🎀

👑 Author 👑

🌸 Further Details 🌸

💅 Further Details — the RFP format lore

🌸 stpttf — the single-precision real one

Purpose

Parameters

Author

Further Details

🦋 ztpttf — the big complex COMPLEX*16 one

Purpose

Parameters

👑 Author 👑

🎀 Further Details 🎀

📍 Definition 📍

💜 Author 💜

🌸 `stpttf` — the single-precision real one

🦋 `ztpttf` — the big complex `COMPLEX*16` one