Struct FieldElement 

pub struct FieldElement<F: FieldInternal> {
    field: F,
    pub(super) value: F::ElementContainer,
}

An element of a field.

This contains the field itself so that it knows how to do arithmetic operations. We want this to be a struct rather than a trait, which means that we want the actual storage of the value to be managed by the field itself. Therefore, we have an internal field trait that knows about arithmetic operations and other implementation details, but these operations are only accessible from outside the crate using this struct.

It might seem wasteful to handle, say, FieldElement<Fp<P>>s rather than u32 in the API for FqVector<Fp<P>>. However, this gives us type-level guarantees that the invariants of the elements hold, i.e. in this case that its value is in the range 0..P. Moreover, this is bigger than a bare F::ElementContainer only when the field has a positive memory footprint. The cases we care most about, Fp<P2>, Fp<P3>, Fp<P5>, and Fp<P7>, are all ZSTs and therefore don’t cause any overhead.

Fields

field: F

value: F::ElementContainer

Implementations

impl<F: FieldInternal> FieldElement<F>

pub(super) fn new(field: F, value: F::ElementContainer) -> Self

Create a new field element. This is only visible to the field module, because the caller is responsible for ensuring that the invariants of value hold.

Handling FieldElements in the API rather than the containers directly has the advantage of being sure at compile-time that the invariants hold.

pub fn field(&self) -> F

pub(crate) fn val(self) -> F::ElementContainer

pub fn inv(self) -> Option<Self>

pub fn frobenius(self) -> Self

Trait Implementations

impl<F: Field> Add for FieldElement<F>

type Output = FieldElement<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Field> AddAssign for FieldElement<F>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F: Clone + FieldInternal> Clone for FieldElement<F>

where F::ElementContainer: Clone,

fn clone(&self) -> FieldElement<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + FieldInternal> Debug for FieldElement<F>

where F::ElementContainer: Debug,

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

Formats the value using the given formatter.

impl<F: FieldInternal> Deref for FieldElement<F>

type Target = <F as FieldInternal>::ElementContainer

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<F: Field> Display for FieldElement<F>

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

Formats the value using the given formatter.

impl<F: Field> Div for FieldElement<F>

type Output = Option<FieldElement<F>>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<P: Prime> From<FieldElement<Fp<P>>> for u32

fn from(element: FieldElement<Fp<P>>) -> Self

Converts to this type from the input type.

impl<F: Hash + FieldInternal> Hash for FieldElement<F>

where F::ElementContainer: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: Field> Mul for FieldElement<F>

type Output = FieldElement<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Field> MulAssign for FieldElement<F>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<F: Field> Neg for FieldElement<F>

type Output = FieldElement<F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F: PartialEq + FieldInternal> PartialEq for FieldElement<F>

where F::ElementContainer: PartialEq,

fn eq(&self, other: &FieldElement<F>) -> 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<F: Field> Sub for FieldElement<F>

type Output = FieldElement<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Field> SubAssign for FieldElement<F>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<F: Copy + FieldInternal> Copy for FieldElement<F>

where F::ElementContainer: Copy,

impl<F: Eq + FieldInternal> Eq for FieldElement<F>

where F::ElementContainer: Eq,

impl<F: FieldInternal> StructuralPartialEq for FieldElement<F>