Type Alias decaf377::fields::fq::Fq

pub type Fq = Fq;

Aliased Type

struct Fq(/* private fields */);

Implementations

impl Fq

pub const MODULUS_LIMBS: [u64; 4] = _

pub const MODULUS_MINUS_ONE_DIV_TWO_LIMBS: [u64; 4] = _

pub const MODULUS_BIT_SIZE: u32 = 253u32

pub const TRACE_LIMBS: [u64; 4] = _

pub const TRACE_MINUS_ONE_DIV_TWO_LIMBS: [u64; 4] = _

pub const TWO_ADICITY: u32 = 47u32

pub const QUADRATIC_NON_RESIDUE_TO_TRACE: Self = _

pub const MULTIPLICATIVE_GENERATOR: Self = _

pub const TWO_ADIC_ROOT_OF_UNITY: Self = _

pub const FIELD_SIZE_POWER_OF_TWO: Self = _

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

pub fn from_bytes_checked(bytes: &[u8; 32]) -> Result<Self, EncodingError>

Convert bytes into an Fq element, returning None if these bytes are not already reduced.

This means that values that cannot be produced by encoding a field element will return None, enforcing canonical serialization.

pub fn to_bytes(&self) -> [u8; 32]

pub fn rand<R: CryptoRngCore>(rng: &mut R) -> Self

Sample a random field element uniformly.

pub fn power<S: AsRef<[u64]>>(&self, exp: S) -> Self

Raise this element to a given power.

Note: Arkworks provides another method for this, called pow.

impl Fq

pub fn sqrt_ratio_zeta(num: &Self, den: &Self) -> (bool, Self)

Computes the square root of a ratio of field elements, returning:

• (true, sqrt(num/den)) if num and den are both nonzero and num/den is square;
• (true, 0) if num is zero;
• (false, 0) if den is zero;
• (false, sqrt(zeta*num/den)) if num and den are both nonzero and num/den is nonsquare;

Trait Implementations

impl Add for Fq

type Output = Fq

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Fq

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl CanonicalDeserialize for Fq

fn deserialize_with_mode<R: Read>( reader: R, _compress: Compress, validate: Validate, ) -> Result<Self, SerializationError>

The general deserialize method that takes in customization flags.

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_compressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>

where R: Read,

fn deserialize_uncompressed_unchecked<R>( reader: R, ) -> Result<Self, SerializationError>

where R: Read,

impl CanonicalDeserializeWithFlags for Fq

fn deserialize_with_flags<R: Read, F: Flags>( reader: R, ) -> Result<(Self, F), SerializationError>

Reads Self and Flags from reader. Returns empty flags by default.

impl CanonicalSerialize for Fq

fn serialize_with_mode<W: Write>( &self, writer: W, _compress: Compress, ) -> Result<(), SerializationError>

The general serialize method that takes in customization flags.

fn serialized_size(&self, _compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>

where W: Write,

fn uncompressed_size(&self) -> usize

impl CanonicalSerializeWithFlags for Fq

fn serialize_with_flags<W: Write, F: Flags>( &self, writer: W, flags: F, ) -> Result<(), SerializationError>

Serializes self and flags into writer.

fn serialized_size_with_flags<F: Flags>(&self) -> usize

Serializes self and flags into writer.

impl Debug for Fq

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

Formats the value using the given formatter.

impl Default for Fq

fn default() -> Self

Returns the “default value” for a type.

impl Display for Fq

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

Formats the value using the given formatter.

impl Div for Fq

type Output = Fq

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign for Fq

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl FftField for Fq

const GENERATOR: Self = Self::MULTIPLICATIVE_GENERATOR

The generator of the multiplicative group of the field

const TWO_ADICITY: u32 = 47u32

Let N be the size of the multiplicative group defined by the field. Then TWO_ADICITY is the two-adicity of N, i.e. the integer s such that N = 2^s * t for some odd integer t.

const TWO_ADIC_ROOT_OF_UNITY: Self = Self::TWO_ADIC_ROOT_OF_UNITY

2^s root of unity computed by GENERATOR^t

const SMALL_SUBGROUP_BASE: Option<u32> = None

An integer b such that there exists a multiplicative subgroup of size b^k for some integer k.

const SMALL_SUBGROUP_BASE_ADICITY: Option<u32> = None

The integer k such that there exists a multiplicative subgroup of size Self::SMALL_SUBGROUP_BASE^k.

const LARGE_SUBGROUP_ROOT_OF_UNITY: Option<Self> = None

GENERATOR^((MODULUS-1) / (2^s * SMALL_SUBGROUP_BASE^SMALL_SUBGROUP_BASE_ADICITY)) Used for mixed-radix FFT.

fn get_root_of_unity(n: u64) -> Option<Self>

Returns the root of unity of order n, if one exists. If no small multiplicative subgroup is defined, this is the 2-adic root of unity of order n (for n a power of 2). If a small multiplicative subgroup is defined, this is the root of unity of order n for the larger subgroup generated by FftConfig::LARGE_SUBGROUP_ROOT_OF_UNITY (for n = 2^i * FftConfig::SMALL_SUBGROUP_BASE^j for some i, j).

impl Field for Fq

type BasePrimeField = Fq

type BasePrimeFieldIter = Once<<Fq as Field>::BasePrimeField>

const SQRT_PRECOMP: Option<SqrtPrecomputation<Self>> = _

Determines the algorithm for computing square roots.

const ZERO: Self = Self::ZERO

The additive identity of the field.

const ONE: Self = Self::ONE

The multiplicative identity of the field.

fn extension_degree() -> u64

Returns the extension degree of this field with respect to Self::BasePrimeField.

fn to_base_prime_field_elements(&self) -> Self::BasePrimeFieldIter

fn from_base_prime_field_elems(elems: &[Self::BasePrimeField]) -> Option<Self>

Convert a slice of base prime field elements into a field element. If the slice length != Self::extension_degree(), must return None.

fn from_base_prime_field(elem: Self::BasePrimeField) -> Self

Constructs a field element from a single base prime field elements.

fn double(&self) -> Self

Returns self + self.

fn double_in_place(&mut self) -> &mut Self

Doubles self in place.

fn neg_in_place(&mut self) -> &mut Self

Negates self in place.

fn from_random_bytes_with_flags<F: Flags>(bytes: &[u8]) -> Option<(Self, F)>

Attempt to deserialize a field element, splitting the bitflags metadata according to F specification. Returns None if the deserialization fails.

fn legendre(&self) -> LegendreSymbol

Returns a LegendreSymbol, which indicates whether this field element is 1 : a quadratic residue 0 : equal to 0 -1 : a quadratic non-residue

fn square(&self) -> Self

Returns self * self.

fn square_in_place(&mut self) -> &mut Self

Squares self in place.

fn inverse(&self) -> Option<Self>

Computes the multiplicative inverse of self if self is nonzero.

fn inverse_in_place(&mut self) -> Option<&mut Self>

If self.inverse().is_none(), this just returns None. Otherwise, it sets self to self.inverse().unwrap().

fn frobenius_map_in_place(&mut self, _power: usize)

Sets self to self^s, where s = Self::BasePrimeField::MODULUS^power. This is also called the Frobenius automorphism.

fn characteristic() -> &'static [u64]

Returns the characteristic of the field, in little-endian representation.

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

Attempt to deserialize a field element. Returns None if the deserialization fails.

fn sqrt(&self) -> Option<Self>

Returns the square root of self, if it exists.

fn sqrt_in_place(&mut self) -> Option<&mut Self>

Sets self to be the square root of self, if it exists.

fn sum_of_products<const T: usize>(a: &[Self; T], b: &[Self; T]) -> Self

Returns sum([a_i * b_i]).

fn frobenius_map(&self, power: usize) -> Self

Returns self^s, where s = Self::BasePrimeField::MODULUS^power. This is also called the Frobenius automorphism.

fn pow<S>(&self, exp: S) -> Self

where S: AsRef<[u64]>,

Returns self^exp, where exp is an integer represented with u64 limbs, least significant limb first.

fn pow_with_table<S>(powers_of_2: &[Self], exp: S) -> Option<Self>

where S: AsRef<[u64]>,

Exponentiates a field element f by a number represented with u64 limbs, using a precomputed table containing as many powers of 2 of f as the 1 + the floor of log2 of the exponent exp, starting from the 1st power. That is, powers_of_2 should equal &[p, p^2, p^4, ..., p^(2^n)] when exp has at most n bits.

impl From<BigInt<4>> for Fq

fn from(int: BigInt<4>) -> Self

Converts Self::BigInteger into Self

impl From<BigUint> for Fq

fn from(val: BigUint) -> Fq

Converts to this type from the input type.

impl From<bool> for Fq

fn from(other: bool) -> Self

Converts to this type from the input type.

impl From<u128> for Fq

fn from(other: u128) -> Self

Converts to this type from the input type.

impl From<u16> for Fq

fn from(other: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Fq

fn from(other: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Fq

fn from(other: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Fq

fn from(other: u8) -> Self

Converts to this type from the input type.

impl FromStr for Fq

type Err = ()

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Fq

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 Mul for Fq

type Output = Fq

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Fq

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl Neg for Fq

type Output = Fq

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl One for Fq

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl Ord for Fq

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialOrd for Fq

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl PrimeField for Fq

type BigInt = BigInt<4>

A BigInteger type that can represent elements of this field.

const MODULUS: Self::BigInt = _

The BLS12-377 scalar field modulus q = 0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001

const MODULUS_MINUS_ONE_DIV_TWO: Self::BigInt = _

The value (p - 1)/ 2.

const MODULUS_BIT_SIZE: u32 = 253u32

The size of the modulus in bits.

const TRACE: Self::BigInt = _

The trace of the field is defined as the smallest integer t such that by 2^s * t = p - 1, and t is coprime to 2.

const TRACE_MINUS_ONE_DIV_TWO: Self::BigInt = _

The value (t - 1)/ 2.

fn from_bigint(repr: Self::BigInt) -> Option<Self>

Construct a prime field element from an integer in the range 0..(p - 1).

fn into_bigint(self) -> Self::BigInt

Converts an element of the prime field into an integer in the range 0..(p - 1).

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

Reads bytes in big-endian, and converts them to a field element. If the integer represented by bytes is larger than the modulus p, this method performs the appropriate reduction.

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

Reads bytes in little-endian, and converts them to a field element. If the integer represented by bytes is larger than the modulus p, this method performs the appropriate reduction.

impl Product for Fq

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl Sub for Fq

type Output = Fq

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Fq

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl Sum for Fq

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Valid for Fq

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>( batch: impl Iterator<Item = &'a Self> + Send, ) -> Result<(), SerializationError>

where Self: 'a,

impl Zero for Fq

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.