transforms
ptwm_core::transforms::fusion
Fused transform implementations for hot pairs
ptwm_core::transforms::fusion
Fused transform implementations for hot pairs
ptwm_core::transforms::fusion
crates/ptwm-core/src/transforms/fusion.rs:1mod fusionFused transform implementations for hot pairs
Each fused op runs both transforms in a single loop, eliminating the
intermediate buffer. These are NOT `Op` implementors; they are internal
helpers used by the fusion picker in `chain::runtime`.
# Fused pairs
- [`FusedIeee16ByteSplit2`] — `BitReorderIeee16` + `ByteSplit{n=2}`
- [`FusedIeee32ByteSplit4`] — `BitReorderIeee32` + `ByteSplit{n=4}`
- [`FusedFp8E4M3NibbleSplit`] — `BitReorderFp8E4M3` + `NibbleSplit`
- [`FusedFp8E5M2NibbleSplit`] — `BitReorderFp8E5M2` + `NibbleSplit`
ptwm_core::transforms::fusion::FusedFp8E4M3NibbleSplit
crates/ptwm-core/src/transforms/fusion.rs:326pub struct FusedFp8E4M3NibbleSplit;Fused `BitReorderFp8E4M3` + `NibbleSplit`.
For each FP8-E4M3FN byte: reorders bits so the exponent is in the high
nibble, then splits into high-nibble (exponent) and low-nibble (sign+mantissa)
planes — all in one pass.
ptwm_core::transforms::fusion::FusedFp8E5M2NibbleSplit
crates/ptwm-core/src/transforms/fusion.rs:428pub struct FusedFp8E5M2NibbleSplit;Fused `BitReorderFp8E5M2` + `NibbleSplit`.
For each FP8-E5M2 byte: reorders bits so the exponent is in the high
nibble, then splits into high-nibble (exponent) and low-nibble (sign+mantissa)
planes — all in one pass.
ptwm_core::transforms::fusion::FusedIeee16ByteSplit2
crates/ptwm-core/src/transforms/fusion.rs:32pub struct FusedIeee16ByteSplit2;Fused `BitReorderIeee16` + `ByteSplit{n=2}`.
In `forward`: applies IEEE-754 16-bit float bit reordering in-place, then
splits even/odd bytes into two planes — all in a single pass.
In `inverse`: merges two planes and reverts the bit reordering.
ptwm_core::transforms::fusion::FusedIeee32ByteSplit4
crates/ptwm-core/src/transforms/fusion.rs:204pub struct FusedIeee32ByteSplit4;Fused `BitReorderIeee32` + `ByteSplit{n=4}`.
Applies IEEE-754 32-bit float bit reordering, then splits bytes into 4
planes by round-robin — all in one pass.