pub trait FieldElement:
Copy
+ Clone
+ Debug
+ Display
+ Default
+ Send
+ Sync
+ Eq
+ PartialEq
+ Sized
+ Add<Self, Output = Self>
+ Sub<Self, Output = Self>
+ Mul<Self, Output = Self>
+ Div<Self, Output = Self>
+ AddAssign<Self>
+ SubAssign<Self>
+ MulAssign<Self>
+ DivAssign<Self>
+ Neg<Output = Self>
+ From<u32>
+ From<u16>
+ From<u8>
+ TryFrom<u64>
+ TryFrom<u128>
+ for<'a> TryFrom<&'a [u8]>
+ ExtensionOf<Self::BaseField>
+ AsBytes
+ Randomizable
+ Serializable
+ Deserializable {
type PositiveInteger: Debug + Copy + PartialEq + PartialOrd + ShrAssign + Shl<u32, Output = Self::PositiveInteger> + Shr<u32, Output = Self::PositiveInteger> + BitAnd<Output = Self::PositiveInteger> + From<u32> + From<u64>;
type BaseField: StarkField;
const EXTENSION_DEGREE: usize;
const ELEMENT_BYTES: usize;
const IS_CANONICAL: bool;
const ZERO: Self;
const ONE: Self;
// Required methods
fn inv(self) -> Self;
fn conjugate(&self) -> Self;
fn base_element(&self, i: usize) -> Self::BaseField;
fn slice_as_base_elements(elements: &[Self]) -> &[Self::BaseField];
fn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self];
fn elements_as_bytes(elements: &[Self]) -> &[u8] ⓘ;
unsafe fn bytes_as_elements(
bytes: &[u8],
) -> Result<&[Self], DeserializationError>;
// Provided methods
fn double(self) -> Self { ... }
fn square(self) -> Self { ... }
fn cube(self) -> Self { ... }
fn exp(self, power: Self::PositiveInteger) -> Self { ... }
fn exp_vartime(self, power: Self::PositiveInteger) -> Self { ... }
}
Expand description
Defines an element in a finite field.
This trait defines basic arithmetic operations for elements in finite fields (e.g. addition subtraction, multiplication, division) as well as several convenience functions (e.g. double, square cube). Moreover, it defines interfaces for serializing and deserializing field elements.
The elements could be in a prime field or an extension of a prime field. Currently, only quadratic and cubic field extensions are supported.
Required Associated Constants§
sourceconst EXTENSION_DEGREE: usize
const EXTENSION_DEGREE: usize
Extension degree of this field with respect to Self::BaseField
. For prime fields,
extension degree should be set to 1.
sourceconst ELEMENT_BYTES: usize
const ELEMENT_BYTES: usize
Number of bytes needed to encode an element
sourceconst IS_CANONICAL: bool
const IS_CANONICAL: bool
True if internal representation of the element is the same as its canonical representation.
Required Associated Types§
sourcetype PositiveInteger: Debug + Copy + PartialEq + PartialOrd + ShrAssign + Shl<u32, Output = Self::PositiveInteger> + Shr<u32, Output = Self::PositiveInteger> + BitAnd<Output = Self::PositiveInteger> + From<u32> + From<u64>
type PositiveInteger: Debug + Copy + PartialEq + PartialOrd + ShrAssign + Shl<u32, Output = Self::PositiveInteger> + Shr<u32, Output = Self::PositiveInteger> + BitAnd<Output = Self::PositiveInteger> + From<u32> + From<u64>
A type defining positive integers big enough to describe a field modulus for
Self::BaseField
with no loss of precision.
sourcetype BaseField: StarkField
type BaseField: StarkField
Base field type for this finite field. For prime fields, BaseField
should be set
to Self
.
Required Methods§
sourcefn inv(self) -> Self
fn inv(self) -> Self
Returns a multiplicative inverse of this field element. If this element is ZERO, ZERO is returned.
sourcefn base_element(&self, i: usize) -> Self::BaseField
fn base_element(&self, i: usize) -> Self::BaseField
Return base filed element component of this field element at the specified index i
.
§Panics
Panics if the specified index is greater than or equal to Self::EXTENSION_DEGREE
.
sourcefn slice_as_base_elements(elements: &[Self]) -> &[Self::BaseField]
fn slice_as_base_elements(elements: &[Self]) -> &[Self::BaseField]
Converts a slice of field elements into a slice of elements in the underlying base field.
For base STARK fields, the input and output slices are the same. For extension fields, the output slice will contain decompositions of each extension element into underlying base field elements.
sourcefn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self]
fn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self]
Convert a slice of base field elements into a slice of field elements.
For base STARK fields, the input and output slices are the same. For extension fields, the output slice will contain a composition of base field elements into extension field elements.
§Panics
Panics if the the length of the provided slice is not divisible by Self::EXTENSION_DEGREE
.
sourcefn elements_as_bytes(elements: &[Self]) -> &[u8] ⓘ
fn elements_as_bytes(elements: &[Self]) -> &[u8] ⓘ
Converts a list of elements into a list of bytes.
The elements may be in the internal representation rather than in the canonical representation. This conversion is intended to be zero-copy (i.e. by re-interpreting the underlying memory).
sourceunsafe fn bytes_as_elements(
bytes: &[u8],
) -> Result<&[Self], DeserializationError>
unsafe fn bytes_as_elements( bytes: &[u8], ) -> Result<&[Self], DeserializationError>
Converts a list of bytes into a list of field elements.
The elements are assumed to encoded in the internal representation rather than in the canonical representation. The conversion is intended to be zero-copy (i.e. by re-interpreting the underlying memory).
§Errors
An error is returned if:
- Memory alignment of
bytes
does not match memory alignment of field element data. - Length of
bytes
does not divide into whole number of elements.
§Safety
This function is unsafe because it does not check whether underlying bytes represent valid field elements according to their internal representation.
Provided Methods§
sourcefn exp(self, power: Self::PositiveInteger) -> Self
fn exp(self, power: Self::PositiveInteger) -> Self
Exponentiates this field element by power
parameter.
sourcefn exp_vartime(self, power: Self::PositiveInteger) -> Self
fn exp_vartime(self, power: Self::PositiveInteger) -> Self
Exponentiates this field element by power
parameter.
This function is expressly variable time, to speed-up verifier computations.