Struct scuttlebutt::field::F2  
source · [−]#[repr(transparent)]pub struct F2(_);Expand description
A field element in the prime-order finite field $\textsf{GF}(2).$
Trait Implementations
sourceimpl AddAssign<&F2> for F2
 
impl AddAssign<&F2> for F2
sourcefn add_assign(&mut self, rhs: &F2)
 
fn add_assign(&mut self, rhs: &F2)
Performs the 
+= operation. Read moresourceimpl AddAssign<F2> for F2
 
impl AddAssign<F2> for F2
sourcefn add_assign(&mut self, rhs: F2)
 
fn add_assign(&mut self, rhs: F2)
Performs the 
+= operation. Read moresourceimpl CanonicalSerialize for F2
 
impl CanonicalSerialize for F2
sourcefn to_bytes(&self) -> GenericArray<u8, Self::ByteReprLen>
 
fn to_bytes(&self) -> GenericArray<u8, Self::ByteReprLen>
Return the canonical byte representation (byte representation of the reduced field element).
type Serializer = F2BitSerializer
type Serializer = F2BitSerializer
A way to serialize field elements of this type. Read more
type Deserializer = F2BitDeserializer
type Deserializer = F2BitDeserializer
A way to deserialize field elements of this type. Read more
type ByteReprLen = UInt<UTerm, B1>
type ByteReprLen = UInt<UTerm, B1>
The number of bytes in the byte representation for this element.
type FromBytesError = BiggerThanModulus
type FromBytesError = BiggerThanModulus
The error that can result from trying to decode an invalid byte sequence.
sourcefn from_bytes(
    buf: &GenericArray<u8, Self::ByteReprLen>
) -> Result<Self, BiggerThanModulus>
 
fn from_bytes(
    buf: &GenericArray<u8, Self::ByteReprLen>
) -> Result<Self, BiggerThanModulus>
Deserialize an element from a byte array. Read more
sourceimpl ConditionallySelectable for F2
 
impl ConditionallySelectable for F2
sourcefn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self
 
fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self
sourcefn conditional_assign(&mut self, other: &Self, choice: Choice)
 
fn conditional_assign(&mut self, other: &Self, choice: Choice)
sourceimpl ConstantTimeEq for F2
 
impl ConstantTimeEq for F2
sourceimpl<'de> Deserialize<'de> for F2
 
impl<'de> Deserialize<'de> for F2
sourcefn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
 
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>
Deserialize this value from the given Serde deserializer. Read more
sourceimpl Distribution<F2> for Standard
 
impl Distribution<F2> for Standard
sourcefn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> F2
 
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> F2
Generate a random value of 
T, using rng as the source of randomness.sourcefn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where
    R: Rng,
 
fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where
    R: Rng,
Create an iterator that generates random values of 
T, using rng as
the source of randomness. Read moresourceimpl<'a> DivAssign<&'a F2> for F2
 
impl<'a> DivAssign<&'a F2> for F2
sourcefn div_assign(&mut self, rhs: &Self)
 
fn div_assign(&mut self, rhs: &Self)
Performs the 
/= operation. Read moresourceimpl DivAssign<F2> for F2
 
impl DivAssign<F2> for F2
sourcefn div_assign(&mut self, rhs: F2)
 
fn div_assign(&mut self, rhs: F2)
Performs the 
/= operation. Read moresourceimpl FiniteField for F2
 
impl FiniteField for F2
type PrimeField = F2
type PrimeField = F2
The prime-order subfield of the finite field.
sourcefn polynomial_modulus() -> Polynomial<Self::PrimeField>
 
fn polynomial_modulus() -> Polynomial<Self::PrimeField>
Multiplication over field elements should be reduced over this polynomial.
type NumberOfBitsInBitDecomposition = UInt<UTerm, B1>
type NumberOfBitsInBitDecomposition = UInt<UTerm, B1>
The number of bits in the bit decomposition of any element of this finite field. Read more
sourcefn bit_decomposition(
    &self
) -> GenericArray<bool, Self::NumberOfBitsInBitDecomposition>
 
fn bit_decomposition(
    &self
) -> GenericArray<bool, Self::NumberOfBitsInBitDecomposition>
Decompose the given field element into bits. Read more
sourcefn decompose<T: FiniteField + IsSubFieldOf<Self>>(
    &self
) -> GenericArray<T, DegreeModulo<T, Self>>
 
fn decompose<T: FiniteField + IsSubFieldOf<Self>>(
    &self
) -> GenericArray<T, DegreeModulo<T, Self>>
sourcefn from_subfield<T: FiniteField + IsSubFieldOf<Self>>(
    arr: &GenericArray<T, DegreeModulo<T, Self>>
) -> Self
 
fn from_subfield<T: FiniteField + IsSubFieldOf<Self>>(
    arr: &GenericArray<T, DegreeModulo<T, Self>>
) -> Self
Create a field element from an array of subfield 
T elements. Read moresourceimpl FiniteRing for F2
 
impl FiniteRing for F2
sourcefn random<R: RngCore + ?Sized>(rng: &mut R) -> Self
 
fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self
This uniformly generates a field element either 0 or 1 for F2 type.
sourcefn random_nonzero<R: RngCore + ?Sized>(_rng: &mut R) -> Self
 
fn random_nonzero<R: RngCore + ?Sized>(_rng: &mut R) -> Self
Generate a random non-zero element.
sourcefn from_uniform_bytes(x: &[u8; 16]) -> Self
 
fn from_uniform_bytes(x: &[u8; 16]) -> Self
Construct an element from the given uniformly chosen random bytes.
sourcefn pow_bounded(&self, n: u128, bound: u16) -> Self
 
fn pow_bounded(&self, n: u128, bound: u16) -> Self
sourcefn pow_var_time(&self, n: u128) -> Self
 
fn pow_var_time(&self, n: u128) -> Self
Compute 
self to the power of n, in non-constant time.sourceimpl IsSubFieldOf<F128b> for F2
 
impl IsSubFieldOf<F128b> for F2
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>
The value $
n$ from above.sourcefn decompose_superfield(fe: &F128b) -> GenericArray<Self, Self::DegreeModulo>
 
fn decompose_superfield(fe: &F128b) -> GenericArray<Self, Self::DegreeModulo>
Turn 
FE into an array of Self, a subfield of FE.sourcefn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F128b
 
fn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F128b
Homomorphically lift an array of 
Self into an FE.sourceimpl IsSubFieldOf<F40b> for F2
 
impl IsSubFieldOf<F40b> for F2
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>
The value $
n$ from above.sourcefn decompose_superfield(fe: &F40b) -> GenericArray<Self, U40>
 
fn decompose_superfield(fe: &F40b) -> GenericArray<Self, U40>
Turn 
FE into an array of Self, a subfield of FE.sourcefn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F40b
 
fn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F40b
Homomorphically lift an array of 
Self into an FE.sourceimpl IsSubFieldOf<F45b> for F2
 
impl IsSubFieldOf<F45b> for F2
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>
The value $
n$ from above.sourcefn decompose_superfield(fe: &F45b) -> GenericArray<Self, U45>
 
fn decompose_superfield(fe: &F45b) -> GenericArray<Self, U45>
Turn 
FE into an array of Self, a subfield of FE.sourcefn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F45b
 
fn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F45b
Homomorphically lift an array of 
Self into an FE.sourceimpl IsSubFieldOf<F56b> for F2
 
impl IsSubFieldOf<F56b> for F2
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>
The value $
n$ from above.sourcefn decompose_superfield(fe: &F56b) -> GenericArray<Self, U56>
 
fn decompose_superfield(fe: &F56b) -> GenericArray<Self, U56>
Turn 
FE into an array of Self, a subfield of FE.sourcefn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F56b
 
fn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F56b
Homomorphically lift an array of 
Self into an FE.sourceimpl IsSubFieldOf<F63b> for F2
 
impl IsSubFieldOf<F63b> for F2
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>
The value $
n$ from above.sourcefn decompose_superfield(fe: &F63b) -> GenericArray<Self, U63>
 
fn decompose_superfield(fe: &F63b) -> GenericArray<Self, U63>
Turn 
FE into an array of Self, a subfield of FE.sourcefn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F63b
 
fn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F63b
Homomorphically lift an array of 
Self into an FE.sourceimpl IsSubFieldOf<F64b> for F2
 
impl IsSubFieldOf<F64b> for F2
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>
type DegreeModulo = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>
The value $
n$ from above.sourcefn decompose_superfield(fe: &F64b) -> GenericArray<Self, Self::DegreeModulo>
 
fn decompose_superfield(fe: &F64b) -> GenericArray<Self, Self::DegreeModulo>
Turn 
FE into an array of Self, a subfield of FE.sourcefn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F64b
 
fn form_superfield(components: &GenericArray<Self, Self::DegreeModulo>) -> F64b
Homomorphically lift an array of 
Self into an FE.sourceimpl MulAssign<&F2> for F2
 
impl MulAssign<&F2> for F2
sourcefn mul_assign(&mut self, rhs: &F2)
 
fn mul_assign(&mut self, rhs: &F2)
Performs the 
*= operation. Read moresourceimpl MulAssign<F2> for F2
 
impl MulAssign<F2> for F2
sourcefn mul_assign(&mut self, rhs: F2)
 
fn mul_assign(&mut self, rhs: F2)
Performs the 
*= operation. Read moresourceimpl SubAssign<&F2> for F2
 
impl SubAssign<&F2> for F2
sourcefn sub_assign(&mut self, rhs: &F2)
 
fn sub_assign(&mut self, rhs: &F2)
Performs the 
-= operation. Read moresourceimpl SubAssign<F2> for F2
 
impl SubAssign<F2> for F2
sourcefn sub_assign(&mut self, rhs: F2)
 
fn sub_assign(&mut self, rhs: F2)
Performs the 
-= operation. Read moreimpl Copy for F2
impl Eq for F2
impl IsSubRingOf<F128b> for F2
impl IsSubRingOf<F40b> for F2
impl IsSubRingOf<F45b> for F2
impl IsSubRingOf<F56b> for F2
impl IsSubRingOf<F63b> for F2
impl IsSubRingOf<F64b> for F2
impl PrimeFiniteField for F2
impl StructuralEq for F2
Auto Trait Implementations
Blanket Implementations
sourceimpl<T> BorrowMut<T> for Twhere
    T: ?Sized,
 
impl<T> BorrowMut<T> for Twhere
    T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
 
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
impl<T> FmtForward for T
impl<T> FmtForward for T
fn fmt_binary(self) -> FmtBinary<Self>where
    Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
    Self: Binary,
Causes 
self to use its Binary implementation when Debug-formatted.fn fmt_display(self) -> FmtDisplay<Self>where
    Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
    Self: Display,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
    Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
    Self: LowerExp,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
    Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
    Self: LowerHex,
fn fmt_octal(self) -> FmtOctal<Self>where
    Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
    Self: Octal,
Causes 
self to use its Octal implementation when Debug-formatted.fn fmt_pointer(self) -> FmtPointer<Self>where
    Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
    Self: Pointer,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
    Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
    Self: UpperExp,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
    Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
    Self: UpperHex,
fn fmt_list(self) -> FmtList<Self>where
    &'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
sourceimpl<FE> IsSubFieldOf<FE> for FEwhere
    FE: FiniteField,
 
impl<FE> IsSubFieldOf<FE> for FEwhere
    FE: FiniteField,
type DegreeModulo = UInt<UTerm, B1>
type DegreeModulo = UInt<UTerm, B1>
The value $
n$ from above.sourcefn decompose_superfield(
    fe: &FE
) -> GenericArray<FE, <FE as IsSubFieldOf<FE>>::DegreeModulo>
 
fn decompose_superfield(
    fe: &FE
) -> GenericArray<FE, <FE as IsSubFieldOf<FE>>::DegreeModulo>
Turn 
FE into an array of Self, a subfield of FE.sourcefn form_superfield(
    components: &GenericArray<FE, <FE as IsSubFieldOf<FE>>::DegreeModulo>
) -> FE
 
fn form_superfield(
    components: &GenericArray<FE, <FE as IsSubFieldOf<FE>>::DegreeModulo>
) -> FE
Homomorphically lift an array of 
Self into an FE.impl<T> Pipe for Twhere
    T: ?Sized,
impl<T> Pipe for Twhere
    T: ?Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
Pipes by value. This is generally the method you want to use. Read more
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
    R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
    R: 'a,
Borrows 
self and passes that borrow into the pipe function. Read morefn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
    R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
    R: 'a,
Mutably borrows 
self and passes that borrow into the pipe function. Read morefn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
    Self: Borrow<B>,
    B: 'a + ?Sized,
    R: 'a,
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> Rwhere
    Self: Borrow<B>,
    B: 'a + ?Sized,
    R: 'a,
fn pipe_borrow_mut<'a, B, R>(
    &'a mut self,
    func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
    Self: BorrowMut<B>,
    B: 'a + ?Sized,
    R: 'a,
fn pipe_borrow_mut<'a, B, R>(
    &'a mut self,
    func: impl FnOnce(&'a mut B) -> R
) -> Rwhere
    Self: BorrowMut<B>,
    B: 'a + ?Sized,
    R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
    Self: AsRef<U>,
    U: 'a + ?Sized,
    R: 'a,
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> Rwhere
    Self: AsRef<U>,
    U: 'a + ?Sized,
    R: 'a,
Borrows 
self, then passes self.as_ref() into the pipe function.fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
    Self: AsMut<U>,
    U: 'a + ?Sized,
    R: 'a,
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> Rwhere
    Self: AsMut<U>,
    U: 'a + ?Sized,
    R: 'a,
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere
    Self: Deref<Target = T>,
    T: 'a + ?Sized,
    R: 'a,
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> Rwhere
    Self: Deref<Target = T>,
    T: 'a + ?Sized,
    R: 'a,
Borrows 
self, then passes self.deref() into the pipe function.impl<T> Tap for T
impl<T> Tap for T
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
    Self: Borrow<B>,
    B: ?Sized,
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Selfwhere
    Self: Borrow<B>,
    B: ?Sized,
Immutable access to the 
Borrow<B> of a value. Read morefn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
    Self: BorrowMut<B>,
    B: ?Sized,
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
    Self: BorrowMut<B>,
    B: ?Sized,
Mutable access to the 
BorrowMut<B> of a value. Read morefn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
    Self: AsRef<R>,
    R: ?Sized,
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Selfwhere
    Self: AsRef<R>,
    R: ?Sized,
Immutable access to the 
AsRef<R> view of a value. Read morefn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
    Self: AsMut<R>,
    R: ?Sized,
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
    Self: AsMut<R>,
    R: ?Sized,
Mutable access to the 
AsMut<R> view of a value. Read morefn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
    Self: Deref<Target = T>,
    T: ?Sized,
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Selfwhere
    Self: Deref<Target = T>,
    T: ?Sized,
Immutable access to the 
Deref::Target of a value. Read morefn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
    Self: DerefMut<Target = T> + Deref,
    T: ?Sized,
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Selfwhere
    Self: DerefMut<Target = T> + Deref,
    T: ?Sized,
Mutable access to the 
Deref::Target of a value. Read morefn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls 
.tap() only in debug builds, and is erased in release builds.fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls 
.tap_mut() only in debug builds, and is erased in release
builds. Read morefn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
    Self: Borrow<B>,
    B: ?Sized,
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Selfwhere
    Self: Borrow<B>,
    B: ?Sized,
Calls 
.tap_borrow() only in debug builds, and is erased in release
builds. Read morefn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
    Self: BorrowMut<B>,
    B: ?Sized,
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Selfwhere
    Self: BorrowMut<B>,
    B: ?Sized,
Calls 
.tap_borrow_mut() only in debug builds, and is erased in release
builds. Read morefn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
    Self: AsRef<R>,
    R: ?Sized,
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Selfwhere
    Self: AsRef<R>,
    R: ?Sized,
Calls 
.tap_ref() only in debug builds, and is erased in release
builds. Read morefn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
    Self: AsMut<R>,
    R: ?Sized,
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Selfwhere
    Self: AsMut<R>,
    R: ?Sized,
Calls 
.tap_ref_mut() only in debug builds, and is erased in release
builds. Read more