Struct Lanes8Word32 

#[repr(C, align(32))]
pub struct Lanes8Word32(pub [u32; 8]);

Eight lanes of Word32 (one 256-bit SIMD register). Operations are lane-wise over the ℤ/2³² ring.

Tuple Fields

0: [u32; 8]

Implementations

impl Lanes8Word32

pub const LANES: usize = 8

The number of lanes.

pub const fn splat(x: u32) -> Lanes8Word32

Broadcast one value into all eight lanes.

pub fn from_words(s: &[Word32]) -> Lanes8Word32

Pack the first eight Word32s of a slice into a lane vector (shorter slices zero-fill).

pub fn to_words(self) -> [Word32; 8]

The lanes as eight Word32s.

pub fn lane(self, i: usize) -> Word32

Lane i (0-based) as a Word32.

pub fn bitxor(self, o: Lanes8Word32) -> Lanes8Word32

Lane-wise XOR (vpxor). #[inline(always)] + compile-time cfg(target_feature="avx2") intrinsics so a hot Logos lane kernel (ChaCha/NTT) inlines register-resident under +avx2 (no per-op #[target_feature] call boundary — that pessimizes ~20× on Keccak-scale kernels).

pub fn bitand(self, o: Lanes8Word32) -> Lanes8Word32

Lane-wise AND (_mm256_and_si256) — the MD5 F/G-function bit mixing; LLVM lowers the loop to one vpand. AND/OR/NOT have no cross-lane dependency, so the scalar form auto-vectorizes cleanly.

pub fn bitor(self, o: Lanes8Word32) -> Lanes8Word32

Lane-wise OR (_mm256_or_si256).

pub fn not(self) -> Lanes8Word32

Lane-wise complement (vpxor with all-ones) — MD5’s ~b/~d terms.

pub fn add(self, o: Lanes8Word32) -> Lanes8Word32

Lane-wise wrapping add in ℤ/2³² (vpaddd) — cfg-inline so it fuses into hot Logos lane kernels.

pub fn rotl(self, n: u32) -> Lanes8Word32

Lane-wise left rotation by n (ChaCha diffusion) — (x<<n)|(x>>(32−n)) via vpslld/vpsrld. cfg-inline; n is taken mod 32 (n = 0 → the 32−n = 32 shift zeroes → identity).

pub fn sub(self, o: Lanes8Word32) -> Lanes8Word32

Lane-wise wrapping subtract in ℤ/2³² (vpsubd) — the i32 NTT butterfly’s difference. cfg-inline.

pub fn montmul32( self, b: Lanes8Word32, q: Lanes8Word32, qinv: Lanes8Word32, ) -> Lanes8Word32

The signed i32 Montgomery multiply — per lane montgomery_reduce(aᵢ·bᵢ) = (aᵢbᵢ − t·q)≫32, t = (aᵢbᵢ mod 2³²)·qinv, the ML-DSA (Dilithium) NTT butterfly’s multiply (q = 8380417, q,qinv broadcast). AVX2: vpmuldq the even and the (≫32) odd 32-bit lanes to eight i64 products, reduce each (the result lands in the high 32 bits), recombine with vpblendd.

pub fn ntt_bcast_lo(self, h: usize) -> Lanes8Word32

Broadcast each 2h-block’s low h lanes into both halves — the within-vector NTT source-low duplication for 8 i32 lanes, stride h ∈ {4,2,1}. h=4→vperm2i128(0x00) (128-bit halves); h=2→vpshufd(0x44); h=1→vpshufd(0xA0). (The byte op is the i16 stride-2h shuffle.)

pub fn ntt_bcast_hi(self, h: usize) -> Lanes8Word32

Broadcast each 2h-block’s high h lanes into both halves. h=4→vperm2i128(0x11); h=2→vpshufd(0xEE); h=1→vpshufd(0xF5).

pub fn ntt_blend(self, o: Lanes8Word32, h: usize) -> Lanes8Word32

Recombine the +/− halves: each 2h-block’s low h from self, high h from o. h=4→vperm2i128(0x30); h=2→vpblendd(0xCC); h=1→vpblendd(0xAA).

Trait Implementations

impl Add for Lanes8Word32

type Output = Lanes8Word32

The resulting type after applying the + operator.

fn add(self, o: Lanes8Word32) -> Lanes8Word32

Performs the + operation.

impl BitAnd for Lanes8Word32

type Output = Lanes8Word32

The resulting type after applying the & operator.

fn bitand(self, o: Lanes8Word32) -> Lanes8Word32

Performs the & operation.

impl BitOr for Lanes8Word32

type Output = Lanes8Word32

The resulting type after applying the | operator.

fn bitor(self, o: Lanes8Word32) -> Lanes8Word32

Performs the | operation.

impl BitXor for Lanes8Word32

type Output = Lanes8Word32

The resulting type after applying the ^ operator.

fn bitxor(self, o: Lanes8Word32) -> Lanes8Word32

Performs the ^ operation.

impl Clone for Lanes8Word32

fn clone(&self) -> Lanes8Word32

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Lanes8Word32

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for Lanes8Word32

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Not for Lanes8Word32

type Output = Lanes8Word32

The resulting type after applying the ! operator.

fn not(self) -> Lanes8Word32

Performs the unary ! operation.

impl PartialEq for Lanes8Word32

fn eq(&self, other: &Lanes8Word32) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Showable for Lanes8Word32

fn format_show(&self, f: &mut Formatter<'_>) -> Result

impl Sub for Lanes8Word32

type Output = Lanes8Word32

The resulting type after applying the - operator.

fn sub(self, o: Lanes8Word32) -> Lanes8Word32

Performs the - operation.

impl WordRotate for Lanes8Word32

fn rotl(self, n: u32) -> Self

fn rotr(self, n: u32) -> Self

impl Copy for Lanes8Word32

impl Eq for Lanes8Word32

impl StructuralPartialEq for Lanes8Word32