Struct PackedRijndael8b 

pub struct PackedRijndael8b<const N: usize>(/* private fields */);

A block of elements of the AES field, held as plain consecutive bytes.

Implementations

impl<const N: usize> PackedRijndael8b<N>

pub fn apply(self, map: ByteMatrix) -> Self

Every element replaced by its image under one F_2-linear map.

pub fn frobenius(self, power_log: usize) -> Self

Every element raised to the power 2^k.

One tabulated map covers any exponent.

Repeated squaring would cost one product per step instead.

pub fn invert_or_zero(self) -> Self

Every element inverted, with zero sent to zero.

The byte-wise hardware inverse is one instruction per register.

The fallback is an addition chain of eleven products per element.

Trait Implementations

impl<const N: usize> Add for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: usize> Add<Gf2> for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: usize> Add<PackedRijndael8b<N>> for Rijndael8b

type Output = PackedRijndael8b<N>

The resulting type after applying the + operator.

fn add(self, rhs: PackedRijndael8b<N>) -> Self::Output

Performs the + operation.

impl<const N: usize> Add<Rijndael8b> for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: usize, T: Into<Self>> AddAssign<T> for PackedRijndael8b<N>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<const N: usize> Algebra<Gf2> for PackedRijndael8b<N>

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

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<const N: usize> Algebra<Rijndael8b> for PackedRijndael8b<N>

fn quadratic_extension_square(a: &[Self; 2], w: F) -> [Self; 2]

Square a[0] + a[1] X modulo X^2 - w.

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<const N: usize> Clone for PackedRijndael8b<N>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Copy for PackedRijndael8b<N>

impl<const N: usize> Debug for PackedRijndael8b<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for PackedRijndael8b<N>

fn default() -> Self

Returns the “default value” for a type.

impl<const N: usize> Distribution<PackedRijndael8b<N>> for StandardUniform

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> PackedRijndael8b<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<const N: usize> Div for PackedRijndael8b<N>

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

Panics

Panics if any position of the divisor is zero.

type Output = PackedRijndael8b<N>

The resulting type after applying the / operator.

impl<const N: usize> Div<Rijndael8b> for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const N: usize> DivAssign for PackedRijndael8b<N>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const N: usize> DivAssign<Rijndael8b> for PackedRijndael8b<N>

fn div_assign(&mut self, rhs: Rijndael8b)

Performs the /= operation.

impl<const N: usize> Eq for PackedRijndael8b<N>

impl<const N: usize> From<Gf2> for PackedRijndael8b<N>

fn from(value: Gf2) -> Self

GF(2) is the prime subfield, embedded as {ZERO, ONE} in every position.

impl<const N: usize> From<Rijndael8b> for PackedRijndael8b<N>

fn from(value: Rijndael8b) -> Self

Converts to this type from the input type.

impl<const N: usize> Mul for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize> Mul<Gf2> for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize> Mul<PackedRijndael8b<N>> for Rijndael8b

type Output = PackedRijndael8b<N>

The resulting type after applying the * operator.

fn mul(self, rhs: PackedRijndael8b<N>) -> Self::Output

Performs the * operation.

impl<const N: usize> Mul<Rijndael8b> for PackedRijndael8b<N>

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

A broadcast plus the byte-wise product beats tabulating the factor as a map.

Callers holding one factor across a loop should hoist its matrix and sweep with that.

type Output = PackedRijndael8b<N>

The resulting type after applying the * operator.

impl<const N: usize, T: Into<Self>> MulAssign<T> for PackedRijndael8b<N>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<const N: usize> Neg for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<const N: usize> PackedField for PackedRijndael8b<N>

type Scalar = Rijndael8b

fn packed_powers(base: Self::Scalar) -> Powers<Self>

Construct an iterator which returns powers of base packed into packed field elements.

fn packed_shifted_powers( base: Self::Scalar, start: Self::Scalar, ) -> Powers<Self>

Construct an iterator which returns powers of base multiplied by start and packed into packed field elements.

fn coeffwise_dot_product<'a, I>(d: usize, pairs: I) -> [Self; 8]

where Self: 'a, I: Iterator<Item = (&'a [Self], Self)>,

Accumulate the products of d coefficient streams against a shared stream of packed base values.

impl<const N: usize> PackedFieldPow2 for PackedRijndael8b<N>

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

Panics

Panics if the block length does not divide the width, or is not a power of two.

impl<const N: usize> PackedValue for PackedRijndael8b<N>

const WIDTH: usize

Number of scalar values packed together.

type Value = Rijndael8b

The scalar type that is packed into this value.

fn from_slice(slice: &[Self::Value]) -> &Self

Interprets a slice of scalar values as a packed value reference.

fn from_slice_mut(slice: &mut [Self::Value]) -> &mut Self

Interprets a mutable slice of scalar values as a mutable packed value.

fn as_slice(&self) -> &[Self::Value]

Returns the underlying scalar values as an immutable slice.

fn as_slice_mut(&mut self) -> &mut [Self::Value]

Returns the underlying scalar values as a mutable slice.

fn from_fn<F: FnMut(usize) -> Self::Value>(f: F) -> Self

Constructs a packed value using a function to generate each element.

fn broadcast(value: Self::Value) -> Self

Create a packed value with all lanes set to the same scalar value.

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

Extract the scalar value at the given SIMD lane.

fn pack_slice(buf: &[Self::Value]) -> &[Self]

Packs a slice of scalar values into a slice of packed values.

fn pack_slice_mut(buf: &mut [Self::Value]) -> &mut [Self]

Converts a mutable slice of scalar values into a mutable slice of packed values.

fn pack_maybe_uninit_slice_mut( buf: &mut [MaybeUninit<Self::Value>], ) -> &mut [MaybeUninit<Self>]

Converts a mutable slice of possibly uninitialized scalar values into a mutable slice of possibly uninitialized packed values.

fn pack_slice_with_suffix(buf: &[Self::Value]) -> (&[Self], &[Self::Value])

Packs a slice into packed values and returns the packed portion and any remaining suffix.

fn pack_slice_with_suffix_mut( buf: &mut [Self::Value], ) -> (&mut [Self], &mut [Self::Value])

Converts a mutable slice of scalar values into a pair:

fn pack_maybe_uninit_slice_with_suffix_mut( buf: &mut [MaybeUninit<Self::Value>], ) -> (&mut [MaybeUninit<Self>], &mut [MaybeUninit<Self::Value>])

Converts a mutable slice of possibly uninitialized scalar values into a pair:

fn unpack_slice(buf: &[Self]) -> &[Self::Value]

Reinterprets a slice of packed values as a flat slice of scalar values.

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

Pack columns from WIDTH rows of scalar values into N packed values.

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

Pack columns using a closure that provides each row’s data.

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

Unpack N packed values into WIDTH rows of N scalars.

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

Unpack N packed values into an iterator of WIDTH rows.

impl<const N: usize> PartialEq for PackedRijndael8b<N>

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

Equality operator ==.

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

Inequality operator !=.

impl<const N: usize> PrimeCharacteristicRing for PackedRijndael8b<N>

fn halve(&self) -> Self

Panics

Always panics: 2 is not invertible in characteristic 2.

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

Panics

Always panics: 2 is not invertible in characteristic 2.

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

Raising to 2^k is one tabulated map, whatever the exponent.

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 = Gf2

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

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

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

fn double(&self) -> Self

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

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

Computes the arithmetic generalization of boolean xor.

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

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

fn from_bool(b: bool) -> Self

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

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 square(&self) -> Self

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

fn cube(&self) -> Self

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

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 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.

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.

impl<const N: usize> Product for PackedRijndael8b<N>

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

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

impl<const N: usize> Product<Rijndael8b> for PackedRijndael8b<N>

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

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

impl<const N: usize> StructuralPartialEq for PackedRijndael8b<N>

impl<const N: usize> Sub for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: usize> Sub<Gf2> for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: usize> Sub<PackedRijndael8b<N>> for Rijndael8b

type Output = PackedRijndael8b<N>

The resulting type after applying the - operator.

fn sub(self, rhs: PackedRijndael8b<N>) -> Self::Output

Performs the - operation.

impl<const N: usize> Sub<Rijndael8b> for PackedRijndael8b<N>

type Output = PackedRijndael8b<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: usize, T: Into<Self>> SubAssign<T> for PackedRijndael8b<N>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<const N: usize> Sum for PackedRijndael8b<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<const N: usize> Sum<Rijndael8b> for PackedRijndael8b<N>

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

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