Type Alias PackedBinomialExtensionField 

pub type PackedBinomialExtensionField<F, PF, const D: usize> = PackedExtField<F, PF, D, Binomial<F>>;

Packed binomial extension field F[X] / (X^D - W), one element per SIMD lane.

Type alias for the unified PackedExtField with Shape = Binomial<F>.

Aliased Type

pub struct PackedBinomialExtensionField<F, PF, const D: usize> { /* private fields */ }

Trait Implementations

impl<F, PF, const D: usize> Add for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F, PF, const D: usize> Add<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F, PF, const D: usize> Add<PF> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F, PF, const D: usize> AddAssign for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F, PF, const D: usize> AddAssign<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn add_assign(&mut self, rhs: BinomialExtensionField<F, D>)

Performs the += operation.

impl<F, PF, const D: usize> AddAssign<PF> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn add_assign(&mut self, rhs: PF)

Performs the += operation.

impl<F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>, const D: usize> Algebra<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[F; N]) -> Self

where F: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl<F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>, const D: usize> Algebra<PF> for PackedBinomialExtensionField<F, PF, D>

fn mixed_dot_product<const N: usize>(a: &[Self; N], f: &[PF; N]) -> Self

where PF: Dup,

Dot product between algebra elements and base field scalars.

const BATCHED_LC_CHUNK: usize = 8

Optimal chunk size for batched_linear_combination.

fn batched_linear_combination(values: &[Self], coeffs: &[F]) -> Self

where F: Dup,

Runtime-length linear combination: Σ values[i] * coeffs[i].

impl<F, PF, const D: usize> BasedVectorSpace<PF> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

const DIMENSION: usize = D

The dimension of the vector space, i.e. the number of elements in its basis.

fn as_basis_coefficients_slice(&self) -> &[PF]

Fixes a basis for the algebra A and uses this to map an element of A to a slice of DIMENSION F elements.

fn from_basis_coefficients_fn<Fn: FnMut(usize) -> PF>(f: Fn) -> Self

Fixes a basis for the algebra A and uses this to map DIMENSION F elements to an element of A. Similar to core:array::from_fn, the DIMENSION F elements are given by Fn(0), ..., Fn(DIMENSION - 1) called in that order.

fn from_basis_coefficients_iter<I: ExactSizeIterator<Item = PF>>( iter: I, ) -> Option<Self>

Fixes a basis for the algebra A and uses this to map DIMENSION F elements to an element of A.

fn flatten_to_base(vec: Vec<Self>) -> Vec<PF>

Convert from a vector of Self to a vector of F by flattening the basis coefficients.

fn reconstitute_from_base(vec: Vec<PF>) -> Vec<Self>

Convert from a vector of F to a vector of Self by combining the basis coefficients.

fn from_basis_coefficients_slice(slice: &[F]) -> Option<Self>

Fixes a basis for the algebra A and uses this to map DIMENSION F elements to an element of A.

fn ith_basis_element(i: usize) -> Option<Self>

Given a basis for the Algebra A, return the i’th basis element.

impl<F: Field, PF: PackedField<Scalar = F>, const D: usize> Default for PackedBinomialExtensionField<F, PF, D>

fn default() -> Self

Returns the “default value” for a type.

impl<F: BinomiallyExtendable<D>, const D: usize> Div for PackedBinomialExtensionField<F, F::Packing, D>

type Output = PackedExtField<F, <F as Field>::Packing, D, Binomial<F>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<F, PF, const D: usize> Div<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the / operator.

fn div(self, rhs: BinomialExtensionField<F, D>) -> Self

Performs the / operation.

impl<F: BinomiallyExtendable<D>, const D: usize> DivAssign for PackedBinomialExtensionField<F, F::Packing, D>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<F, PF, const D: usize> DivAssign<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn div_assign(&mut self, rhs: BinomialExtensionField<F, D>)

Performs the /= operation.

impl<F: Field, PF: PackedField<Scalar = F>, const D: usize> From<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

fn from(x: BinomialExtensionField<F, D>) -> Self

Converts to this type from the input type.

impl<F: Field, PF: PackedField<Scalar = F>, const D: usize> From<PF> for PackedBinomialExtensionField<F, PF, D>

fn from(x: PF) -> Self

Converts to this type from the input type.

impl<F, PF, const D: usize> Mul for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F, PF, const D: usize> Mul<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F, PF, const D: usize> Mul<PF> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F, PF, const D: usize> MulAssign for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<F, PF, const D: usize> MulAssign<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn mul_assign(&mut self, rhs: BinomialExtensionField<F, D>)

Performs the *= operation.

impl<F, PF, const D: usize> MulAssign<PF> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn mul_assign(&mut self, rhs: PF)

Performs the *= operation.

impl<F, PF, const D: usize> Neg for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<F, const D: usize> PackedFieldExtension<F, ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, F::Packing, D>

where F: BinomiallyExtendable<D>,

fn from_ext_fn(f: impl Fn(usize) -> BinomialExtensionField<F, D>) -> Self

Construct a packed extension by applying f to each lane.

fn packed_ext_powers(base: BinomialExtensionField<F, D>) -> Powers<Self>

Similar to packed_powers, construct an iterator which returns powers of base packed into PackedFieldExtension elements.

fn from_ext_slice(slice: &[ExtField]) -> Self

Pack a length-WIDTH slice of extension field elements into one packed extension.

fn pack_ext_columns<const N: usize>(rows: &[[ExtField; N]]) -> [Self; N]

Pack N columns from W rows of extension field elements into N packed extensions.

fn pack_ext_columns_fn<const N: usize>( row_fn: impl Fn(usize) -> [ExtField; N], ) -> [Self; N]

Pack N columns using a closure that produces each row.

fn extract(&self, lane: usize) -> ExtField

Extract the extension field element at the given SIMD lane.

fn to_ext_slice(&self, out: &mut [ExtField])

Write all W lanes into the given slice.

fn unpack_ext_into<const N: usize>( packed: &[Self; N], rows: &mut [[ExtField; N]], )

Unpack N packed extensions into W rows of N extension elements.

fn unpack_ext_iter<const N: usize>( packed: [Self; N], ) -> impl Iterator<Item = [ExtField; N]>

Iterator equivalent of PackedFieldExtension::unpack_ext_into.

fn to_ext_iter( iter: impl IntoIterator<Item = Self>, ) -> impl Iterator<Item = ExtField>

Convert an iterator of packed extension field elements to an iterator of extension field elements (flat — one ExtField per lane per packed value).

fn packed_ext_powers_capped( base: ExtField, unpacked_len: usize, ) -> impl Iterator<Item = Self>

Similar to packed_ext_powers but only returns unpacked_len powers of base.

impl<F, PF, const D: usize> PrimeCharacteristicRing for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

const ZERO: Self

The additive identity of the ring.

const ONE: Self

The multiplicative identity of the ring.

const TWO: Self

The element in the ring given by ONE + ONE.

const NEG_ONE: Self

The element in the ring given by -ONE.

type PrimeSubfield = <PF as PrimeCharacteristicRing>::PrimeSubfield

The field ℤ/p where the characteristic of this ring is p.

fn from_prime_subfield(val: Self::PrimeSubfield) -> Self

Embed an element of the prime field ℤ/p into the ring R.

fn from_bool(b: bool) -> Self

Return Self::ONE if b is true and Self::ZERO if b is false.

fn halve(&self) -> Self

The elementary function halve(a) = a/2.

fn square(&self) -> Self

The elementary function square(a) = a^2.

fn mul_2exp_u64(&self, exp: u64) -> Self

The elementary function mul_2exp_u64(a, exp) = a * 2^{exp}.

fn div_2exp_u64(&self, exp: u64) -> Self

Divide by a given power of two. div_2exp_u64(a, exp) = a/2^exp

fn zero_vec(len: usize) -> Vec<Self>

Allocates a vector of zero elements of length len. Many operating systems zero pages before assigning them to a userspace process. In that case, our process should not need to write zeros, which would be redundant. However, the compiler may not always recognize this.

fn from_u8(int: u8) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u16(int: u16) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u32(int: u32) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u64(int: u64) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_u128(int: u128) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_usize(int: usize) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i8(int: i8) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i16(int: i16) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i32(int: i32) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i64(int: i64) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_i128(int: i128) -> Self

Given an integer r, return the sum of r copies of ONE:

fn from_isize(int: isize) -> Self

Given an integer r, return the sum of r copies of ONE:

fn double(&self) -> Self

The elementary function double(a) = 2*a.

fn cube(&self) -> Self

The elementary function cube(a) = a^3.

fn xor(&self, y: &Self) -> Self

Computes the arithmetic generalization of boolean xor.

fn xor3(&self, y: &Self, z: &Self) -> Self

Computes the arithmetic generalization of a triple xor.

fn andn(&self, y: &Self) -> Self

Computes the arithmetic generalization of andnot.

fn bool_check(&self) -> Self

The vanishing polynomial for boolean values: x * (x - 1).

fn exp_u64(&self, power: u64) -> Self

Exponentiation by a u64 power.

fn exp_const_u64<const POWER: u64>(&self) -> Self

Exponentiation by a small constant power.

fn exp_power_of_2(&self, power_log: usize) -> Self

The elementary function exp_power_of_2(a, power_log) = a^{2^power_log}.

fn powers(&self) -> Powers<Self>

Construct an iterator which returns powers of self: self^0, self^1, self^2, ....

fn shifted_powers(&self, start: Self) -> Powers<Self>

Construct an iterator which returns powers of self shifted by start: start, start*self^1, start*self^2, ....

fn dot_product<const N: usize>(u: &[Self; N], v: &[Self; N]) -> Self

Compute the dot product of two vectors.

fn sum_array<const N: usize>(input: &[Self]) -> Self

Compute the sum of a slice of elements whose length is a compile time constant.

impl<F, PF, const D: usize> Product for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

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

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

impl<F, PF, const D: usize> Sub for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F, PF, const D: usize> Sub<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F, PF, const D: usize> Sub<PF> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

type Output = PackedExtField<F, PF, D, Binomial<F>>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F, PF, const D: usize> SubAssign for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<F, PF, const D: usize> SubAssign<ExtField<F, D, Binomial<F>>> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn sub_assign(&mut self, rhs: BinomialExtensionField<F, D>)

Performs the -= operation.

impl<F, PF, const D: usize> SubAssign<PF> for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

fn sub_assign(&mut self, rhs: PF)

Performs the -= operation.

impl<F, PF, const D: usize> Sum for PackedBinomialExtensionField<F, PF, D>

where F: BinomiallyExtendable<D>, PF: PackedField<Scalar = F>,

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

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