Struct Block256 

#[repr(C, align(32))]
pub struct Block256(pub [u128; 2]);

GF(2^256) in the tower basis: lo + hi·X over Block128, stored as [lo, hi].

Tuple Fields

0: [u128; 2]

Implementations

impl Block256

pub fn new(lo: Block128, hi: Block128) -> Self

Builds lo + hi·X from its halves.

pub fn split(self) -> (Block128, Block128)

Returns the halves (lo, hi) of lo + hi·X.

Trait Implementations

impl Add for Block256

type Output = Block256

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Block256

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl BinaryFieldExtras for Block256

fn square(&self) -> Self

Returns self^2; squaring is additive in characteristic 2.

fn trace(&self) -> Bit

Returns the absolute trace Σ_{i<BITS} self^(2^i), always 0 or 1; the tower fields compute it as a masked parity.

fn solve_quadratic(c: Self) -> Option<Self>

Returns a root of x^2 + x = c, or None iff Tr(c) = 1; the other root is result + ONE. The fixed choice defines the Cantor basis. The value path is constant time; only Some/None reveals Tr(c).

fn frobenius(&self, k: u32) -> Self

Returns self^(2^k), k reduced mod BITS since x^(2^BITS) = x; costs k % BITS squarings.

impl CanonicalDeserialize for Block256

fn deserialize(bytes: &[u8]) -> Result<Self, ()>

Reads an element from the start of bytes; ignores the rest.

impl CanonicalSerialize for Block256

fn serialized_size(&self) -> usize

Returns the encoded length in bytes.

fn serialize(&self, writer: &mut [u8]) -> Result<(), ()>

Writes the encoding to the start of writer; later bytes are left as they are.

fn to_bytes(&self) -> Vec<u8>

Encodes self into a new Vec<u8> of serialized_size() bytes.

impl Clone for Block256

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Block256

impl Debug for Block256

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

Formats the value using the given formatter.

impl Default for Block256

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Block256

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Block256

impl FlatPromote<Block8> for Block256

fn promote_flat(val: Flat<Block8>) -> Flat<Self>

Maps a flat FromF element into the flat basis of Self.

fn promote_flat_batch(input: &[Flat<Block8>], output: &mut [Flat<Self>])

Promotes input[i] into output[i] for every i below the shorter length; the rest of output is left as it is.

impl FlatPromote<Block16> for Block256

fn promote_flat(val: Flat<Block16>) -> Flat<Self>

Maps a flat FromF element into the flat basis of Self.

fn promote_flat_batch(input: &[Flat<Block16>], output: &mut [Flat<Self>])

Promotes input[i] into output[i] for every i below the shorter length; the rest of output is left as it is.

impl FlatPromote<Block32> for Block256

fn promote_flat(val: Flat<Block32>) -> Flat<Self>

Maps a flat FromF element into the flat basis of Self.

fn promote_flat_batch(input: &[Flat<Block32>], output: &mut [Flat<Self>])

Promotes input[i] into output[i] for every i below the shorter length; the rest of output is left as it is.

impl FlatPromote<Block64> for Block256

fn promote_flat(val: Flat<Block64>) -> Flat<Self>

Maps a flat FromF element into the flat basis of Self.

fn promote_flat_batch(input: &[Flat<Block64>], output: &mut [Flat<Self>])

Promotes input[i] into output[i] for every i below the shorter length; the rest of output is left as it is.

impl FlatPromote<Block128> for Block256

fn promote_flat(val: Flat<Block128>) -> Flat<Self>

Maps a flat FromF element into the flat basis of Self.

fn promote_flat_batch(input: &[Flat<Block128>], output: &mut [Flat<Self>])

Promotes input[i] into output[i] for every i below the shorter length; the rest of output is left as it is.

impl From<Bit> for Block256

fn from(val: Bit) -> Self

Converts to this type from the input type.

impl From<Block8> for Block256

fn from(val: Block8) -> Self

Converts to this type from the input type.

impl From<Block16> for Block256

fn from(val: Block16) -> Self

Converts to this type from the input type.

impl From<Block32> for Block256

fn from(val: Block32) -> Self

Converts to this type from the input type.

impl From<Block64> for Block256

fn from(val: Block64) -> Self

Converts to this type from the input type.

impl From<Block128> for Block256

fn from(val: Block128) -> Self

Converts to this type from the input type.

impl From<u8> for Block256

fn from(val: u8) -> Self

Converts to this type from the input type.

impl From<u32> for Block256

fn from(val: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Block256

fn from(val: u64) -> Self

Converts to this type from the input type.

impl From<u128> for Block256

fn from(val: u128) -> Self

Converts to this type from the input type.

impl HardwareField for Block256

fn to_hardware(self) -> Flat<Self>

Maps self to the flat basis: φ(self).

fn from_hardware(value: Flat<Self>) -> Self

Maps value back to the tower basis: φ⁻¹(value).

fn add_hardware(lhs: Flat<Self>, rhs: Flat<Self>) -> Flat<Self>

Adds two flat elements (XOR).

fn add_hardware_packed( lhs: PackedFlat<Self>, rhs: PackedFlat<Self>, ) -> PackedFlat<Self>

Adds two packed flat vectors lane by lane (XOR).

fn mul_hardware(lhs: Flat<Self>, rhs: Flat<Self>) -> Flat<Self>

Multiplies two flat elements.

fn mul_hardware_packed( lhs: PackedFlat<Self>, rhs: PackedFlat<Self>, ) -> PackedFlat<Self>

Multiplies two packed flat vectors lane by lane.

fn mul_hardware_scalar_packed( lhs: PackedFlat<Self>, rhs: Flat<Self>, ) -> PackedFlat<Self>

Multiplies every lane of lhs by the flat scalar rhs.

fn tower_bit_from_hardware(value: Flat<Self>, bit_idx: usize) -> u8

Returns bit bit_idx of φ⁻¹(value) without a full conversion; constant time in value.

impl Mul for Block256

type Output = Block256

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Block256> for PackedBlock256

type Output = PackedBlock256

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Block256

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulAssign<Block256> for PackedBlock256

fn mul_assign(&mut self, rhs: Block256)

Performs the *= operation.

impl PackableField for Block256

const WIDTH: usize = PACKED_WIDTH_256

How many elements fit in one packed vector.

type Packed = PackedBlock256

The packed form; operators act lane by lane.

fn pack(chunk: &[Self]) -> Self::Packed

Packs chunk[..WIDTH] into one value; ignores the rest.

fn unpack(packed: Self::Packed, output: &mut [Self])

Writes the lanes of packed to output[..WIDTH]; the rest of output is left as it is.

impl PartialEq for Block256

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Block256

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Block256

impl Sub for Block256

type Output = Block256

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Block256

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl TowerField for Block256

const BITS: usize = 256

Degree over GF(2): 2^BITS elements.

const ZERO: Self

The additive identity.

const ONE: Self

The multiplicative identity.

const EXTENSION_TAU: Self = Self::TAU

τ of the next level, F[X] / (X^2 + X + τ), for Block8 up. Tr(τ) = 1 makes X^2 + X + τ irreducible.

fn invert(&self) -> Self

Returns self^-1, or 0 for 0. No branch on the value in the default build.

fn from_uniform_bytes(bytes: &[u8; 32]) -> Self

Builds the element from the first BITS bits of bytes, little-endian; ignores the rest.

impl Zeroize for Block256

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.