Struct SlicedPackedField 

pub struct SlicedPackedField<F, PSub, const N: usize>(/* private fields */);

A packed extension field stored as N packed subfield coordinate registers.

F is the extension scalar, PSub the packed subfield holding one coordinate of every lane, and N = <F as ExtensionField<PSub::Scalar>>::DEGREE the extension degree. See the module documentation for the layout and for which operations are generic here versus supplied per concrete extension.

Concrete packings are named through type aliases; see packed_ghash_sq for GHASH².

use binius_field::{Divisible, Field, GhashSq256b, PackedField, SlicedGhashSq2x256b};

let scalars = [GhashSq256b::ONE, GhashSq256b::MULTIPLICATIVE_GENERATOR];
let a = SlicedGhashSq2x256b::from_scalars(scalars);
let squared = a * a;
for i in 0..SlicedGhashSq2x256b::WIDTH {
    assert_eq!(squared.get(i), scalars[i] * scalars[i]);
}

Implementations

impl<F, PSub: PackedField, const N: usize> SlicedPackedField<F, PSub, N>

pub const fn from_coords(coords: [PSub; N]) -> Self

Wraps N coordinate registers, where coords[j] holds the β_j coordinate of every lane.

pub const fn to_coords(self) -> [PSub; N]

Unwraps the N coordinate registers.

Trait Implementations

impl<F, PSub: PackedField, const N: usize> Add<&SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the + operator.

fn add(self, rhs: &Self) -> Self

Performs the + operation.

impl<F, PSub, const N: usize> Add<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField,

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the + operator.

fn add(self, rhs: F) -> Self

Performs the + operation.

impl<F, PSub: PackedField, const N: usize> Add for SlicedPackedField<F, PSub, N>

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<F, PSub: PackedField, const N: usize> AddAssign<&SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<F, PSub, const N: usize> AddAssign<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField,

fn add_assign(&mut self, rhs: F)

Performs the += operation.

impl<F, PSub: PackedField, const N: usize> AddAssign for SlicedPackedField<F, PSub, N>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F, PSub: Copy, const N: usize> Clone for SlicedPackedField<F, PSub, N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F, PSub: PackedField, const N: usize> Debug for SlicedPackedField<F, PSub, N>

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

Formats the value using the given formatter.

impl<F, PSub: PackedField, const N: usize> Default for SlicedPackedField<F, PSub, N>

fn default() -> Self

Returns the “default value” for a type.

impl<F, PSub: PackedField, const N: usize> Distribution<SlicedPackedField<F, PSub, N>> for StandardUniform

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> SlicedPackedField<F, PSub, N>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<F, PSub, const N: usize> Divisible<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField,

const LOG_N: usize = PSub::LOG_WIDTH

The log2 of the number of T elements that fit in Self.

fn value_iter(value: Self) -> impl ExactSizeIterator<Item = F> + Send + Clone

Returns an iterator over subdivisions of this underlier value, ordered from LSB to MSB.

fn ref_iter( value: &Self, ) -> impl ExactSizeIterator<Item = F> + Send + Clone + '_

Returns an iterator over subdivisions of this underlier reference, ordered from LSB to MSB.

fn slice_iter( slice: &[Self], ) -> impl ExactSizeIterator<Item = F> + Send + Clone + '_

Returns an iterator over subdivisions of a slice of underliers, ordered from LSB to MSB.

unsafe fn get_unchecked(&self, index: usize) -> F

Get element at index (LSB-first ordering) without bounds checking.

unsafe fn set_unchecked(&mut self, index: usize, val: F)

Set element at index (LSB-first ordering) in place, without bounds checking.

fn broadcast(val: F) -> Self

Create a value with val broadcast to all N positions.

fn from_iter(iter: impl Iterator<Item = F>) -> Self

Construct a value from an iterator of elements.

const N: usize = _

The number of T elements that fit in Self.

fn get(&self, index: usize) -> T

Get element at index (LSB-first ordering).

fn set(&mut self, index: usize, val: T)

Set element at index (LSB-first ordering), in place.

impl<F, PSub, const N: usize> FieldOps for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField, Self: Square + InvertOrZero + Mul<Output = Self>,

type Scalar = F

fn zero() -> Self

Returns the zero element (additive identity).

fn one() -> Self

Returns the one element (multiplicative identity).

fn square_transpose<FSub: Field>(elems: &mut [Self])

where F: ExtensionField<FSub>,

Transpose the subfield elements in a slice of field elements.

impl<F, PSub, const N: usize> Maskable<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField,

type Mask = <PSub as Maskable<<PSub as FieldOps>::Scalar>>::Mask

A precomputed mask selecting which T-lanes select keeps.

fn make_mask(selectors: impl Iterator<Item = bool>) -> Self::Mask

Builds a mask from per-lane boolean selectors, in LSB-to-MSB lane order (the same ordering as Divisible). Consumes at most Divisible::N selectors; any lane past the end of the iterator, or whose selector is false, is not selected.

fn select(&self, mask: &Self::Mask) -> Self

Returns a value keeping the lanes selected when mask was built and zeroing the rest.

impl<F, PSub: PackedField, const N: usize> Mul<&SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

where Self: Mul<Output = Self>,

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the * operator.

fn mul(self, rhs: &Self) -> Self

Performs the * operation.

impl<F, PSub, const N: usize> Mul<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField, Self: Mul<Output = Self>,

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the * operator.

fn mul(self, rhs: F) -> Self

Performs the * operation.

impl<F, PSub: PackedField, const N: usize> Mul for SlicedPackedField<F, PSub, N>

where Self: WideMul,

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<F, PSub: PackedField, const N: usize> MulAssign<&SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

where Self: Mul<Output = Self>,

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<F, PSub, const N: usize> MulAssign<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField, Self: Mul<Output = Self>,

fn mul_assign(&mut self, rhs: F)

Performs the *= operation.

impl<F, PSub: PackedField, const N: usize> MulAssign for SlicedPackedField<F, PSub, N>

where Self: Mul<Output = Self>,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<F, PSub: PackedField, const N: usize> Neg for SlicedPackedField<F, PSub, N>

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<F, PSub, const N: usize> PackedField for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField, Self: Square + InvertOrZero + Mul<Output = Self> + WideMul<Output: Debug + Send + Sync + 'static>,

fn interleave(self, other: Self, log_block_len: usize) -> (Self, Self)

Interleaves blocks of this packed vector with another packed vector.

fn unzip(self, other: Self, log_block_len: usize) -> (Self, Self)

Unzips interleaved blocks of this packed vector with another packed vector.

fn from_fn(f: impl FnMut(usize) -> Self::Scalar) -> Self

Construct a packed field element from a function that returns scalar values by index.

unsafe fn spread_unchecked(self, log_block_len: usize, block_idx: usize) -> Self

Unsafe version of Self::spread.

const LOG_WIDTH: usize = _

Base-2 logarithm of the number of field elements packed into one packed element.

const WIDTH: usize = _

The number of field elements packed into one packed element.

fn into_iter(self) -> impl Iterator<Item = Self::Scalar> + Send + Clone

fn iter(&self) -> impl Iterator<Item = Self::Scalar> + Send + Clone + '_

fn iter_slice( slice: &[Self], ) -> impl Iterator<Item = Self::Scalar> + Send + Clone + '_

fn set_single(scalar: Self::Scalar) -> Self

Initialize zero position with scalar, set other elements to zero.

fn from_scalars(values: impl IntoIterator<Item = Self::Scalar>) -> Self

Construct a packed field element from a sequence of scalars.

fn pow(self, exp: u64) -> Self

Returns the value to the power exp.

fn spread(self, log_block_len: usize, block_idx: usize) -> Self

Spread takes a block of elements within a packed field and repeats them to the full packing width.

impl<F, PSub: PartialEq, const N: usize> PartialEq for SlicedPackedField<F, PSub, N>

fn eq(&self, other: &Self) -> 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<'a, F, PSub: PackedField, const N: usize> Product<&'a SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, Self: Mul<Output = Self>,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<F, PSub: PackedField, const N: usize> Product for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, Self: Mul<Output = Self>,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<F, PSub: PackedField, const N: usize> Sub<&SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self

Performs the - operation.

impl<F, PSub, const N: usize> Sub<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField,

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the - operator.

fn sub(self, rhs: F) -> Self

Performs the - operation.

impl<F, PSub: PackedField, const N: usize> Sub for SlicedPackedField<F, PSub, N>

type Output = SlicedPackedField<F, PSub, N>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<F, PSub: PackedField, const N: usize> SubAssign<&SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl<F, PSub, const N: usize> SubAssign<F> for SlicedPackedField<F, PSub, N>

where F: ExtensionField<PSub::Scalar>, PSub: PackedField,

fn sub_assign(&mut self, rhs: F)

Performs the -= operation.

impl<F, PSub: PackedField, const N: usize> SubAssign for SlicedPackedField<F, PSub, N>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a, F, PSub: PackedField, const N: usize> Sum<&'a SlicedPackedField<F, PSub, N>> for SlicedPackedField<F, PSub, N>

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<F, PSub: PackedField, const N: usize> Sum for SlicedPackedField<F, PSub, N>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<F, PSub: Zeroable, const N: usize> Zeroable for SlicedPackedField<F, PSub, N>

fn zeroed() -> Self

Calls zeroed.

impl<F, PSub: Copy, const N: usize> Copy for SlicedPackedField<F, PSub, N>

impl<F, PSub: Eq, const N: usize> Eq for SlicedPackedField<F, PSub, N>