Struct ExtElem 

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

Instances of ExtElem are elements of a finite field F_p^4. They are represented as elements of F_p[X] / (X^4 + 11). This large finite field (about 2^128 elements) is used when the security of operations depends on the size of the field. The field extension ExtElem has Elem as a subfield, so operations on elements of each are compatible. The irreducible polynomial x^4 + 11 was chosen because 11 is the simplest choice of BETA for x^4 + BETA that makes this polynomial irreducible.

Implementations

impl ExtElem

pub const fn new(x0: Elem, x1: Elem, x2: Elem, x3: Elem) -> Self

Explicitly construct an ExtElem from parts.

pub fn from_fp(x: Elem) -> Self

Create an ExtElem from an Elem.

pub const fn from_u32(x0: u32) -> Self

Create an ExtElem from a raw integer.

pub fn const_part(self) -> Elem

Return the base field term of an Elem.

pub fn elems(&self) -> &[Elem]

Return Elem as a vector of base field values.

Trait Implementations

impl Add<Elem> for ExtElem

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

Addition for Baby Bear Elem

type Output = ExtElem

The resulting type after applying the + operator.

impl Add<ExtElem> for Elem

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

Addition for Baby Bear Elem

type Output = ExtElem

The resulting type after applying the + operator.

impl Add for ExtElem

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

Addition for Baby Bear ExtElem

type Output = ExtElem

The resulting type after applying the + operator.

impl AddAssign<Elem> for ExtElem

fn add_assign(&mut self, rhs: Elem)

Promoting addition case for BabyBear Elem

impl AddAssign for ExtElem

fn add_assign(&mut self, rhs: Self)

Simple addition case for Baby Bear ExtElem

impl CheckedBitPattern for ExtElem

fn is_valid_bit_pattern(bits: &[u32; 4]) -> bool

Checks that the u32 array elements are all less than the modulus.

type Bits = [u32; 4]

Self must have the same layout as the specified Bits except for the possible invalid bit patterns being checked during is_valid_bit_pattern.

impl Clone for ExtElem

fn clone(&self) -> ExtElem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExtElem

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

Formats the value using the given formatter.

impl Default for ExtElem

fn default() -> Self

Returns the “default value” for a type.

impl Elem for ExtElem

fn random(rng: &mut impl RngCore) -> Self

Generate a random field element uniformly.

fn pow(self, n: usize) -> Self

Raise a ExtElem to a power of n.

fn inv(self) -> Self

Compute the multiplicative inverse of an ExtElem.

fn from_u64(val: u64) -> Self

Convert from a u64 to a base field elem, then cast to the extension field.

const INVALID: Self

Invalid, a value that is not a member of the field. This should only be used with the “is_valid” or “unwrap_or_zero” methods.

const ZERO: Self

Zero, the additive identity.

const ONE: Self

One, the multiplicative identity.

const WORDS: usize = 4usize

How many u32 words are required to hold a single element

fn to_u32_words(&self) -> Vec<u32>

Represent a field element as a sequence of u32s

fn from_u32_words(val: &[u32]) -> Self

Interpret a sequence of u32s as a field element

fn is_valid(&self) -> bool

Returns true if this element is not INVALID. Unlike most methods, this may be called on an INVALID element.

fn is_reduced(&self) -> bool

Returns true if this element is represented in reduced/normalized form. Every element has exactly one reduced form. For a field of prime order P, this typically means the underlying data is < P, and for an extension field, this typically means every component is in reduced form.

fn valid_or_zero(&self) -> Self

Returns 0 if this element is INVALID, else the value of this element. Unlike most methods, this may be called on an INVALID element.

fn ensure_valid(&self) -> &Self

Returns this element, but checks to make sure it’s valid.

fn ensure_reduced(&self) -> &Self

Returns this element, but checks to make sure it’s in reduced form.

fn as_u32_slice(elems: &[Self]) -> &[u32]

Interprets a slice of these elements as u32s. These elements may not be INVALID.

fn as_u32_slice_unchecked(elems: &[Self]) -> &[u32]

Interprets a slice of these elements as u32s. These elements may potentially be INVALID.

fn from_u32_slice(u32s: &[u32]) -> &[Self]

Interprets a slice of u32s as a slice of these elements. These elements may not be INVALID.

impl ExtElem for ExtElem

fn subelems(&self) -> &[Elem]

Returns the subelements of a Elem.

const EXT_SIZE: usize = 4usize

The degree of the field extension

type SubElem = Elem

An element of the base field

fn from_subfield(elem: &Elem) -> Self

Interpret a base field element as an extension field element

fn from_subelems(elems: impl IntoIterator<Item = Self::SubElem>) -> Self

Construct an extension field element

impl From<[Elem; 4]> for ExtElem

fn from(val: [Elem; 4]) -> Self

Converts to this type from the input type.

impl From<Elem> for ExtElem

fn from(x: Elem) -> Self

Converts to this type from the input type.

impl From<u32> for ExtElem

fn from(x: u32) -> Self

Converts to this type from the input type.

impl Mul<Elem> for ExtElem

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

Multiplication by a Baby Bear Elem

type Output = ExtElem

The resulting type after applying the * operator.

impl Mul<ExtElem> for Elem

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

Multiplication for a subfield Elem by an ExtElem

type Output = ExtElem

The resulting type after applying the * operator.

impl Mul for ExtElem

type Output = ExtElem

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<Elem> for ExtElem

fn mul_assign(&mut self, rhs: Elem)

Simple multiplication case by a Baby Bear Elem

impl MulAssign for ExtElem

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for ExtElem

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<Elem> for ExtElem

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

Subtraction for Baby Bear ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

impl Sub<ExtElem> for Elem

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

Subtraction for Baby Bear ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

impl Sub for ExtElem

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

Subtraction for Baby Bear ExtElem

type Output = ExtElem

The resulting type after applying the - operator.

impl SubAssign<Elem> for ExtElem

fn sub_assign(&mut self, rhs: Elem)

Promoting subtraction case for BabyBear Elem

impl SubAssign for ExtElem

fn sub_assign(&mut self, rhs: Self)

Simple subtraction case for Baby Bear ExtElem

impl Zeroable for ExtElem

fn zeroed() -> Self

Calls zeroed.

impl Copy for ExtElem

impl Eq for ExtElem

impl NoUninit for ExtElem