Struct winter_math::fields::f128::BaseElement

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

Represents a base field element.

Internal values are stored in their canonical form in the range [0, M). The backing type is u128.

Implementations

impl BaseElement

pub const fn new(value: u128) -> Self

Creates a new field element from a u128 value. If the value is greater than or equal to the field modulus, modular reduction is silently performed. This function can also be used to initialize constants.

Trait Implementations

impl Add for BaseElement

type Output = BaseElement

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for BaseElement

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl AsBytes for BaseElement

fn as_bytes(&self) -> &[u8]

Returns a byte representation of self.

impl Clone for BaseElement

fn clone(&self) -> BaseElement

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BaseElement

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

Formats the value using the given formatter.

impl Default for BaseElement

fn default() -> BaseElement

Returns the “default value” for a type.

impl Deserializable for BaseElement

fn read_from<R: ByteReader>( source: &mut R ) -> Result<Self, DeserializationError>

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

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

Attempts to deserialize the provided bytes into Self and returns the result.

impl Display for BaseElement

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

Formats the value using the given formatter.

impl Div for BaseElement

type Output = BaseElement

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign for BaseElement

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl ExtensibleField<2> for BaseElement

Defines a quadratic extension of the base field over an irreducible polynomial x² - x - 1. Thus, an extension element is defined as α + β * φ, where φ is a root of this polynomial, and α and β are base field elements.

fn mul(a: [Self; 2], b: [Self; 2]) -> [Self; 2]

Returns a product of a and b in the field defined by this extension.

fn mul_base(a: [Self; 2], b: Self) -> [Self; 2]

Returns a product of a and b in the field defined by this extension. b represents an element in the base field.

fn frobenius(x: [Self; 2]) -> [Self; 2]

Returns Frobenius automorphisms for x in the field defined by this extension.

fn square(a: [Self; N]) -> [Self; N]

Returns the square of a in the field defined by this extension.

fn is_supported() -> bool

Returns true if this extension is supported for the underlying base field.

impl ExtensibleField<3> for BaseElement

Cubic extension for this field is not implemented as quadratic extension already provides sufficient security level.

fn mul(_a: [Self; 3], _b: [Self; 3]) -> [Self; 3]

Returns a product of a and b in the field defined by this extension.

fn mul_base(_a: [Self; 3], _b: Self) -> [Self; 3]

Returns a product of a and b in the field defined by this extension. b represents an element in the base field.

fn frobenius(_x: [Self; 3]) -> [Self; 3]

Returns Frobenius automorphisms for x in the field defined by this extension.

fn is_supported() -> bool

Returns true if this extension is supported for the underlying base field.

fn square(a: [Self; N]) -> [Self; N]

Returns the square of a in the field defined by this extension.

impl FieldElement for BaseElement

type PositiveInteger = u128

A type defining positive integers big enough to describe a field modulus for Self::BaseField with no loss of precision.

type BaseField = BaseElement

Base field type for this finite field. For prime fields, BaseField should be set to Self.

const EXTENSION_DEGREE: usize = 1usize

Extension degree of this field with respect to Self::BaseField. For prime fields, extension degree should be set to 1.

const ZERO: Self = _

The additive identity.

const ONE: Self = _

The multiplicative identity.

const ELEMENT_BYTES: usize = 16usize

Number of bytes needed to encode an element

const IS_CANONICAL: bool = true

True if internal representation of the element is the same as its canonical representation.

fn inv(self) -> Self

Returns a multiplicative inverse of this field element. If this element is ZERO, ZERO is returned.

fn conjugate(&self) -> Self

Returns a conjugate of this field element.

fn base_element(&self, i: usize) -> Self::BaseField

Return base filed element component of this field element at the specified index i.

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.

fn slice_from_base_elements(elements: &[Self::BaseField]) -> &[Self]

Convert a slice of base field elements into a slice of field elements.

fn elements_as_bytes(elements: &[Self]) -> &[u8]

Converts a list of elements into a list of bytes.

unsafe fn bytes_as_elements( bytes: &[u8] ) -> Result<&[Self], DeserializationError>

Converts a list of bytes into a list of field elements.

fn double(self) -> Self

Returns this field element added to itself.

fn square(self) -> Self

Returns this field element raised to power 2.

fn cube(self) -> Self

Returns this field element raised to power 3.

fn exp(self, power: Self::PositiveInteger) -> Self

Exponentiates this field element by power parameter.

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.

impl From<u16> for BaseElement

fn from(value: u16) -> Self

Converts a 16-bit value into a field element.

impl From<u32> for BaseElement

fn from(value: u32) -> Self

Converts a 32-bit value into a field element.

impl From<u64> for BaseElement

fn from(value: u64) -> Self

Converts a 64-bit value into a field element.

impl From<u8> for BaseElement

fn from(value: u8) -> Self

Converts an 8-bit value into a field element.

impl Mul for BaseElement

type Output = BaseElement

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for BaseElement

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for BaseElement

type Output = BaseElement

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for BaseElement

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Randomizable for BaseElement

const VALUE_SIZE: usize = 16usize

Size of Self in bytes.

fn from_random_bytes(bytes: &[u8]) -> Option<Self>

Returns Self if the set of bytes forms a valid value, otherwise returns None.

impl Serializable for BaseElement

fn write_into<W: ByteWriter>(&self, target: &mut W)

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl StarkField for BaseElement

const MODULUS: Self::PositiveInteger = {transmute(0xffffffffffffffffffffd30000000001): <field::f128::BaseElement as field::traits::FieldElement>::PositiveInteger}

sage: MODULUS = 2^128 - 45 * 2^40 + 1
sage: GF(MODULUS).is_prime_field()
True
sage: GF(MODULUS).order()
340282366920938463463374557953744961537

const GENERATOR: Self = _

sage: GF(MODULUS).primitive_element()
3

const TWO_ADICITY: u32 = 40u32

sage: is_odd((MODULUS - 1) / 2^40)
True

const TWO_ADIC_ROOT_OF_UNITY: Self = _

sage: k = (MODULUS - 1) / 2^40
sage: GF(MODULUS).primitive_element()^k
23953097886125630542083529559205016746

const MODULUS_BITS: u32 = 128u32

The number of bits needed to represents Self::MODULUS.

fn get_modulus_le_bytes() -> Vec<u8>

Returns byte representation of the field modulus in little-endian byte order.

fn as_int(&self) -> Self::PositiveInteger

Returns a canonical integer representation of this field element.

fn get_root_of_unity(n: u32) -> Self

Returns the root of unity of order 2^n.

fn from_bytes_with_padding(bytes: &[u8]) -> Self

Converts a slice of bytes into a field element. Pads the slice if it is smaller than the number of bytes needed to represent an element.

impl Sub for BaseElement

type Output = BaseElement

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for BaseElement

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a> TryFrom<&'a [u8]> for BaseElement

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

Converts a slice of bytes into a field element; returns error if the value encoded in bytes is not a valid field element. The bytes are assumed to be in little-endian byte order.

type Error = String

The type returned in the event of a conversion error.

impl TryFrom<u128> for BaseElement

type Error = String

The type returned in the event of a conversion error.

fn try_from(value: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl Copy for BaseElement

impl Eq for BaseElement

impl StructuralPartialEq for BaseElement