Struct Bit 

pub struct Bit(/* private fields */);

GF(2) element; the inner byte is invariantly 0 or 1.

Implementations

impl Bit

pub const fn new(val: u8) -> Self

Builds the element from the low bit of val.

pub const fn try_new(val: u8) -> Option<Self>

Returns the element if val is 0 or 1, else None.

pub const fn get(self) -> u8

Returns the value, always 0 or 1.

Trait Implementations

impl Add for Bit

Add (XOR) 0+0=0, 0+1=1, 1+0=1, 1+1=0

type Output = Bit

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Bit

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl CanonicalDeserialize for Bit

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

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

impl CanonicalSerialize for Bit

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 Bit

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 Bit

impl Debug for Bit

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

Formats the value using the given formatter.

impl Default for Bit

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Bit

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Bit

impl From<Bit> for Block128

fn from(val: Bit) -> Self

Converts to this type from the input type.

impl From<Bit> for Block16

fn from(val: Bit) -> Self

Converts to this type from the input type.

impl From<Bit> for Block256

fn from(val: Bit) -> Self

Converts to this type from the input type.

impl From<Bit> for Block32

fn from(val: Bit) -> Self

Converts to this type from the input type.

impl From<Bit> for Block64

fn from(val: Bit) -> Self

Converts to this type from the input type.

impl From<Bit> for Block8

fn from(val: Bit) -> Self

Converts to this type from the input type.

impl From<u8> for Bit

fn from(val: u8) -> Self

Converts to this type from the input type.

impl From<u32> for Bit

fn from(val: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Bit

fn from(val: u64) -> Self

Converts to this type from the input type.

impl From<u128> for Bit

fn from(val: u128) -> Self

Converts to this type from the input type.

impl HardwareField for Bit

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 Bit

Mul (AND) 00=0, 01=0, 1*1=1

type Output = Bit

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Bit> for PackedBit

type Output = PackedBit

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Bit

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl PackableField for Bit

const WIDTH: usize = PACKED_WIDTH_BIT

How many elements fit in one packed vector.

type Packed = PackedBit

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 Bit

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Bit

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 Bit

impl Sub for Bit

Sub is the same as add

type Output = Bit

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Bit

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl TowerField for Bit

const BITS: usize = 1

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

const ZERO: Self

The additive identity.

const ONE: Self

The multiplicative identity.

const EXTENSION_TAU: Self

τ 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 Bit

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.