pub trait PrimeField: Field + From<u64> {
    type Repr: Copy + Default + Send + Sync + 'static + AsRef<[u8]> + AsMut<[u8]>;

    const MODULUS: &'static str;
    const NUM_BITS: u32;
    const CAPACITY: u32;
    const TWO_INV: Self;
    const MULTIPLICATIVE_GENERATOR: Self;
    const S: u32;
    const ROOT_OF_UNITY: Self;
    const ROOT_OF_UNITY_INV: Self;
    const DELTA: Self;

    // Required methods
    fn from_repr(repr: Self::Repr) -> CtOption<Self>;
    fn to_repr(&self) -> Self::Repr;
    fn is_odd(&self) -> Choice;

    // Provided methods
    fn from_str_vartime(s: &str) -> Option<Self> { ... }
    fn from_u128(v: u128) -> Self { ... }
    fn from_repr_vartime(repr: Self::Repr) -> Option<Self> { ... }
    fn is_even(&self) -> Choice { ... }
}
Expand description

This represents an element of a non-binary prime field.

Required Associated Types§

type Repr: Copy + Default + Send + Sync + 'static + AsRef<[u8]> + AsMut<[u8]>

The prime field can be converted back and forth into this binary representation.

Required Associated Constants§

const MODULUS: &'static str

Modulus of the field written as a string for debugging purposes.

The encoding of the modulus is implementation-specific. Generic users of the PrimeField trait should treat this string as opaque.

const NUM_BITS: u32

How many bits are needed to represent an element of this field.

const CAPACITY: u32

How many bits of information can be reliably stored in the field element.

This is usually Self::NUM_BITS - 1.

const TWO_INV: Self

Inverse of $2$ in the field.

const MULTIPLICATIVE_GENERATOR: Self

A fixed multiplicative generator of modulus - 1 order. This element must also be a quadratic nonresidue.

It can be calculated using SageMath as GF(modulus).primitive_element().

Implementations of this trait MUST ensure that this is the generator used to derive Self::ROOT_OF_UNITY.

const S: u32

An integer s satisfying the equation 2^s * t = modulus - 1 with t odd.

This is the number of leading zero bits in the little-endian bit representation of modulus - 1.

const ROOT_OF_UNITY: Self

The 2^s root of unity.

It can be calculated by exponentiating Self::MULTIPLICATIVE_GENERATOR by t, where t = (modulus - 1) >> Self::S.

const ROOT_OF_UNITY_INV: Self

Inverse of Self::ROOT_OF_UNITY.

const DELTA: Self

Generator of the t-order multiplicative subgroup.

It can be calculated by exponentiating Self::MULTIPLICATIVE_GENERATOR by 2^s, where s is Self::S.

Required Methods§

fn from_repr(repr: Self::Repr) -> CtOption<Self>

Attempts to convert a byte representation of a field element into an element of this prime field, failing if the input is not canonical (is not smaller than the field’s modulus).

The byte representation is interpreted with the same endianness as elements returned by PrimeField::to_repr.

fn to_repr(&self) -> Self::Repr

Converts an element of the prime field into the standard byte representation for this field.

The endianness of the byte representation is implementation-specific. Generic encodings of field elements should be treated as opaque.

fn is_odd(&self) -> Choice

Returns true iff this element is odd.

Provided Methods§

fn from_str_vartime(s: &str) -> Option<Self>

Interpret a string of numbers as a (congruent) prime field element. Does not accept unnecessary leading zeroes or a blank string.

§Security

This method provides no constant-time guarantees.

fn from_u128(v: u128) -> Self

Obtains a field element congruent to the integer v.

For fields where Self::CAPACITY >= 128, this is injective and will produce a unique field element.

For fields where Self::CAPACITY < 128, this is surjective; some field elements will be produced by multiple values of v.

If you want to deterministically sample a field element representing a value, use FromUniformBytes instead.

fn from_repr_vartime(repr: Self::Repr) -> Option<Self>

Attempts to convert a byte representation of a field element into an element of this prime field, failing if the input is not canonical (is not smaller than the field’s modulus).

The byte representation is interpreted with the same endianness as elements returned by PrimeField::to_repr.

§Security

This method provides no constant-time guarantees. Implementors of the PrimeField trait may optimise this method using non-constant-time logic.

fn is_even(&self) -> Choice

Returns true iff this element is even.

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

§

impl PrimeField for Fp

§

type Repr = [u8; 32]

§

const MODULUS: &'static str = "0x40000000000000000000000000000000224698fc094cf91b992d30ed00000001"

§

const TWO_INV: Fp = _

§

const NUM_BITS: u32 = 255u32

§

const CAPACITY: u32 = 254u32

§

const MULTIPLICATIVE_GENERATOR: Fp = GENERATOR

§

const S: u32 = 32u32

§

const ROOT_OF_UNITY: Fp = ROOT_OF_UNITY

§

const ROOT_OF_UNITY_INV: Fp = _

§

const DELTA: Fp = DELTA

§

fn from_u128(v: u128) -> Fp

§

fn from_repr(repr: <Fp as PrimeField>::Repr) -> CtOption<Fp>

§

fn to_repr(&self) -> <Fp as PrimeField>::Repr

§

fn is_odd(&self) -> Choice

§

impl PrimeField for Fq

§

type Repr = [u8; 32]

§

const MODULUS: &'static str = "0x40000000000000000000000000000000224698fc0994a8dd8c46eb2100000001"

§

const NUM_BITS: u32 = 255u32

§

const CAPACITY: u32 = 254u32

§

const TWO_INV: Fq = _

§

const MULTIPLICATIVE_GENERATOR: Fq = GENERATOR

§

const S: u32 = 32u32

§

const ROOT_OF_UNITY: Fq = ROOT_OF_UNITY

§

const ROOT_OF_UNITY_INV: Fq = _

§

const DELTA: Fq = DELTA

§

fn from_u128(v: u128) -> Fq

§

fn from_repr(repr: <Fq as PrimeField>::Repr) -> CtOption<Fq>

§

fn to_repr(&self) -> <Fq as PrimeField>::Repr

§

fn is_odd(&self) -> Choice

Implementors§