Struct QuadExtField

pub struct QuadExtField<P>
where
    P: QuadExtConfig,
{
    pub c0: <P as QuadExtConfig>::BaseField,
    pub c1: <P as QuadExtConfig>::BaseField,
}

An element of a quadratic extension field F_p[X]/(X^2 - P::NONRESIDUE) is represented as c0 + c1 * X, for c0, c1 in P::BaseField.

Fields

c0: <P as QuadExtConfig>::BaseField

Coefficient c0 in the representation of the field element c = c0 + c1 * X

c1: <P as QuadExtConfig>::BaseField

Coefficient c1 in the representation of the field element c = c0 + c1 * X

Implementations

impl<P> QuadExtField<Fp2ConfigWrapper<P>>

where P: Fp2Config,

pub fn mul_assign_by_fp(&mut self, other: &<P as Fp2Config>::Fp)

In-place multiply both coefficients c0 and c1 of self by an element from Fp.

Examples

let c0: Fp = Fp::rand(&mut test_rng());
let c1: Fp = Fp::rand(&mut test_rng());
let mut ext_element: Fp2 = Fp2::new(c0, c1);

let base_field_element: Fp = Fp::rand(&mut test_rng());
ext_element.mul_assign_by_fp(&base_field_element);

assert_eq!(ext_element.c0, c0 * base_field_element);
assert_eq!(ext_element.c1, c1 * base_field_element);

impl<P> QuadExtField<Fp4ConfigWrapper<P>>

where P: Fp4Config,

pub fn mul_by_fp( &mut self, element: &<<P as Fp4Config>::Fp2Config as Fp2Config>::Fp, )

pub fn mul_by_fp2( &mut self, element: &QuadExtField<Fp2ConfigWrapper<<P as Fp4Config>::Fp2Config>>, )

impl<P> QuadExtField<Fp6ConfigWrapper<P>>

where P: Fp6Config,

pub fn mul_by_034( &mut self, c0: &<<P as Fp6Config>::Fp3Config as Fp3Config>::Fp, c3: &<<P as Fp6Config>::Fp3Config as Fp3Config>::Fp, c4: &<<P as Fp6Config>::Fp3Config as Fp3Config>::Fp, )

pub fn mul_by_014( &mut self, c0: &<<P as Fp6Config>::Fp3Config as Fp3Config>::Fp, c1: &<<P as Fp6Config>::Fp3Config as Fp3Config>::Fp, c4: &<<P as Fp6Config>::Fp3Config as Fp3Config>::Fp, )

impl<P> QuadExtField<Fp12ConfigWrapper<P>>

where P: Fp12Config,

pub fn mul_by_fp( &mut self, element: &<QuadExtField<Fp12ConfigWrapper<P>> as Field>::BasePrimeField, )

pub fn mul_by_034( &mut self, c0: &QuadExtField<Fp2ConfigWrapper<<<P as Fp12Config>::Fp6Config as Fp6Config>::Fp2Config>>, c3: &QuadExtField<Fp2ConfigWrapper<<<P as Fp12Config>::Fp6Config as Fp6Config>::Fp2Config>>, c4: &QuadExtField<Fp2ConfigWrapper<<<P as Fp12Config>::Fp6Config as Fp6Config>::Fp2Config>>, )

pub fn mul_by_014( &mut self, c0: &QuadExtField<Fp2ConfigWrapper<<<P as Fp12Config>::Fp6Config as Fp6Config>::Fp2Config>>, c1: &QuadExtField<Fp2ConfigWrapper<<<P as Fp12Config>::Fp6Config as Fp6Config>::Fp2Config>>, c4: &QuadExtField<Fp2ConfigWrapper<<<P as Fp12Config>::Fp6Config as Fp6Config>::Fp2Config>>, )

impl<P> QuadExtField<P>

where P: QuadExtConfig,

pub const fn new( c0: <P as QuadExtConfig>::BaseField, c1: <P as QuadExtConfig>::BaseField, ) -> QuadExtField<P>

Create a new field element from coefficients c0 and c1, so that the result is of the form c0 + c1 * X.

Examples

let c0: Fp = Fp::rand(&mut test_rng());
let c1: Fp = Fp::rand(&mut test_rng());
// `Fp2` a degree-2 extension over `Fp`.
let c: Fp2 = Fp2::new(c0, c1);

pub fn conjugate_in_place(&mut self) -> &mut QuadExtField<P>

This is only to be used when the element is known to be in the cyclotomic subgroup.

pub fn norm(&self) -> <P as QuadExtConfig>::BaseField

Norm of QuadExtField over P::BaseField:Norm(a) = a * a.conjugate(). This simplifies to: Norm(a) = a.x^2 - P::NON_RESIDUE * a.y^2. This is alternatively expressed as Norm(a) = a^(1 + p).

Examples

let c: Fp2 = Fp2::rand(&mut test_rng());
let norm = c.norm();
// We now compute the norm using the `a * a.conjugate()` approach.
// A Frobenius map sends an element of `Fp2` to one of its p_th powers:
// `a.frobenius_map_in_place(1) -> a^p` and `a^p` is also `a`'s Galois conjugate.
let mut c_conjugate = c;
c_conjugate.frobenius_map_in_place(1);
let norm2 = c * c_conjugate;
// Computing the norm of an `Fp2` element should result in an element
// in BaseField `Fp`, i.e. `c1 == 0`
assert!(norm2.c1.is_zero());
assert_eq!(norm, norm2.c0);

pub fn mul_assign_by_basefield( &mut self, element: &<P as QuadExtConfig>::BaseField, )

In-place multiply both coefficients c0 & c1 of the quadratic extension field by an element from the base field.

Trait Implementations

impl<'a, 'b, P> Add<&'a QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the + operator.

fn add(self, other: &'a QuadExtField<P>) -> QuadExtField<P>

Performs the + operation.

impl<'a, P> Add<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the + operator.

fn add(self, other: &QuadExtField<P>) -> QuadExtField<P>

Performs the + operation.

impl<'a, 'b, P> Add<&'a mut QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the + operator.

fn add(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the + operation.

impl<'a, P> Add<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the + operator.

fn add(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the + operation.

impl<'b, P> Add<QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the + operator.

fn add(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the + operation.

impl<P> Add for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the + operator.

fn add(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the + operation.

impl<'a, P> AddAssign<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn add_assign(&mut self, other: &QuadExtField<P>)

Performs the += operation.

impl<'a, P> AddAssign<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn add_assign(&mut self, other: &'a mut QuadExtField<P>)

Performs the += operation.

impl<P> AddAssign for QuadExtField<P>

where P: QuadExtConfig,

fn add_assign(&mut self, other: QuadExtField<P>)

Performs the += operation.

impl<P> AdditiveGroup for QuadExtField<P>

where P: QuadExtConfig,

const ZERO: QuadExtField<P> = _

The additive identity of the field.

type Scalar = QuadExtField<P>

fn double(&self) -> QuadExtField<P>

Doubles self.

fn double_in_place(&mut self) -> &mut QuadExtField<P>

Doubles self in place.

fn neg_in_place(&mut self) -> &mut QuadExtField<P>

Negates self in place.

impl<P> CanonicalDeserialize for QuadExtField<P>

where P: QuadExtConfig,

fn deserialize_with_mode<R>( reader: R, compress: Compress, validate: Validate, ) -> Result<QuadExtField<P>, SerializationError>

where R: Read,

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<P> CanonicalDeserializeWithFlags for QuadExtField<P>

where P: QuadExtConfig,

fn deserialize_with_flags<R, F>( reader: R, ) -> Result<(QuadExtField<P>, F), SerializationError>

where R: Read, F: Flags,

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

impl<P> CanonicalSerialize for QuadExtField<P>

where P: QuadExtConfig,

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

where W: Write,

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<P> CanonicalSerializeWithFlags for QuadExtField<P>

where P: QuadExtConfig,

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

where W: Write, F: Flags,

Serializes self and flags into writer.

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

where F: Flags,

Serializes self and flags into writer.

impl<P> Clone for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: Copy,

fn clone(&self) -> QuadExtField<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P> CyclotomicMultSubgroup for QuadExtField<Fp12ConfigWrapper<P>>

where P: Fp12Config,

const INVERSE_IS_FAST: bool = true

Is the inverse fast to compute? For example, in quadratic extensions, the inverse can be computed at the cost of negating one coordinate, which is much faster than standard inversion. By default this is false, but should be set to true for quadratic extensions.

fn cyclotomic_inverse_in_place( &mut self, ) -> Option<&mut QuadExtField<Fp12ConfigWrapper<P>>>

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_square_in_place( &mut self, ) -> &mut QuadExtField<Fp12ConfigWrapper<P>>

Square self in place. By default this is computed using Field::square_in_place, but for degree 12 extensions, this can be computed faster than normal squaring.

fn cyclotomic_square(&self) -> Self

Compute a square in the cyclotomic subgroup. By default this is computed using Field::square, but for degree 12 extensions, this can be computed faster than normal squaring.

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

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_exp(&self, e: impl AsRef<[u64]>) -> Self

Compute a cyclotomic exponentiation of self with respect to e.

fn cyclotomic_exp_in_place(&mut self, e: impl AsRef<[u64]>)

Set self to be the result of exponentiating self by e, using efficient cyclotomic algorithms.

impl<P> CyclotomicMultSubgroup for QuadExtField<Fp2ConfigWrapper<P>>

where P: Fp2Config,

const INVERSE_IS_FAST: bool = true

Is the inverse fast to compute? For example, in quadratic extensions, the inverse can be computed at the cost of negating one coordinate, which is much faster than standard inversion. By default this is false, but should be set to true for quadratic extensions.

fn cyclotomic_inverse_in_place( &mut self, ) -> Option<&mut QuadExtField<Fp2ConfigWrapper<P>>>

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_square(&self) -> Self

Compute a square in the cyclotomic subgroup. By default this is computed using Field::square, but for degree 12 extensions, this can be computed faster than normal squaring.

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

Square self in place. By default this is computed using Field::square_in_place, but for degree 12 extensions, this can be computed faster than normal squaring.

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

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_exp(&self, e: impl AsRef<[u64]>) -> Self

Compute a cyclotomic exponentiation of self with respect to e.

fn cyclotomic_exp_in_place(&mut self, e: impl AsRef<[u64]>)

Set self to be the result of exponentiating self by e, using efficient cyclotomic algorithms.

impl<P> CyclotomicMultSubgroup for QuadExtField<Fp4ConfigWrapper<P>>

where P: Fp4Config,

const INVERSE_IS_FAST: bool = true

Is the inverse fast to compute? For example, in quadratic extensions, the inverse can be computed at the cost of negating one coordinate, which is much faster than standard inversion. By default this is false, but should be set to true for quadratic extensions.

fn cyclotomic_inverse_in_place( &mut self, ) -> Option<&mut QuadExtField<Fp4ConfigWrapper<P>>>

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_square(&self) -> Self

Compute a square in the cyclotomic subgroup. By default this is computed using Field::square, but for degree 12 extensions, this can be computed faster than normal squaring.

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

Square self in place. By default this is computed using Field::square_in_place, but for degree 12 extensions, this can be computed faster than normal squaring.

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

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_exp(&self, e: impl AsRef<[u64]>) -> Self

Compute a cyclotomic exponentiation of self with respect to e.

fn cyclotomic_exp_in_place(&mut self, e: impl AsRef<[u64]>)

Set self to be the result of exponentiating self by e, using efficient cyclotomic algorithms.

impl<P> CyclotomicMultSubgroup for QuadExtField<Fp6ConfigWrapper<P>>

where P: Fp6Config,

const INVERSE_IS_FAST: bool = true

Is the inverse fast to compute? For example, in quadratic extensions, the inverse can be computed at the cost of negating one coordinate, which is much faster than standard inversion. By default this is false, but should be set to true for quadratic extensions.

fn cyclotomic_inverse_in_place( &mut self, ) -> Option<&mut QuadExtField<Fp6ConfigWrapper<P>>>

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_square(&self) -> Self

Compute a square in the cyclotomic subgroup. By default this is computed using Field::square, but for degree 12 extensions, this can be computed faster than normal squaring.

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

Square self in place. By default this is computed using Field::square_in_place, but for degree 12 extensions, this can be computed faster than normal squaring.

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

Compute the inverse of self. See Self::INVERSE_IS_FAST for details. Returns None if self.is_zero(), and Some otherwise.

fn cyclotomic_exp(&self, e: impl AsRef<[u64]>) -> Self

Compute a cyclotomic exponentiation of self with respect to e.

fn cyclotomic_exp_in_place(&mut self, e: impl AsRef<[u64]>)

Set self to be the result of exponentiating self by e, using efficient cyclotomic algorithms.

impl<P> Debug for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: Debug,

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

Formats the value using the given formatter.

impl<P> Default for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: Default,

fn default() -> QuadExtField<P>

Returns the “default value” for a type.

impl<P> Display for QuadExtField<P>

where P: QuadExtConfig,

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

Formats the value using the given formatter.

impl<'a, 'b, P> Div<&'a QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the / operator.

fn div(self, other: &'a QuadExtField<P>) -> QuadExtField<P>

Performs the / operation.

impl<'a, P> Div<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the / operator.

fn div(self, other: &QuadExtField<P>) -> QuadExtField<P>

Performs the / operation.

impl<'a, 'b, P> Div<&'a mut QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the / operator.

fn div(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the / operation.

impl<'a, P> Div<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the / operator.

fn div(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the / operation.

impl<'b, P> Div<QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the / operator.

fn div(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the / operation.

impl<P> Div for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the / operator.

fn div(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the / operation.

impl<'a, P> DivAssign<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn div_assign(&mut self, other: &QuadExtField<P>)

Performs the /= operation.

impl<'a, P> DivAssign<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn div_assign(&mut self, other: &'a mut QuadExtField<P>)

Performs the /= operation.

impl<P> DivAssign for QuadExtField<P>

where P: QuadExtConfig,

fn div_assign(&mut self, other: QuadExtField<P>)

Performs the /= operation.

impl<P> FftField for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: FftField,

const GENERATOR: QuadExtField<P> = _

The generator of the multiplicative group of the field

const TWO_ADICITY: u32 = <P::BaseField>::TWO_ADICITY

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: QuadExtField<P> = _

2^s root of unity computed by GENERATOR^t

const SMALL_SUBGROUP_BASE: Option<u32> = <P::BaseField>::SMALL_SUBGROUP_BASE

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> = <P::BaseField>::SMALL_SUBGROUP_BASE_ADICITY

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

const LARGE_SUBGROUP_ROOT_OF_UNITY: Option<QuadExtField<P>> = _

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<P> Field for QuadExtField<P>

where P: QuadExtConfig,

const SQRT_PRECOMP: Option<SqrtPrecomputation<QuadExtField<P>>> = None

Determines the algorithm for computing square roots.

const ONE: QuadExtField<P> = _

The multiplicative identity of the field.

type BasePrimeField = <P as QuadExtConfig>::BasePrimeField

fn extension_degree() -> u64

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

fn from_base_prime_field( elem: <QuadExtField<P> as Field>::BasePrimeField, ) -> QuadExtField<P>

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

fn to_base_prime_field_elements( &self, ) -> impl Iterator<Item = <QuadExtField<P> as Field>::BasePrimeField>

fn from_base_prime_field_elems( elems: impl IntoIterator<Item = <QuadExtField<P> as Field>::BasePrimeField>, ) -> Option<QuadExtField<P>>

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

fn square(&self) -> QuadExtField<P>

Returns self * self.

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

where F: Flags,

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

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

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

fn square_in_place(&mut self) -> &mut QuadExtField<P>

Squares self in place.

fn inverse(&self) -> Option<QuadExtField<P>>

Computes the multiplicative inverse of self if self is nonzero.

fn inverse_in_place(&mut self) -> Option<&mut QuadExtField<P>>

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 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 sqrt(&self) -> Option<QuadExtField<P>>

Returns the square root of self, if it exists.

fn sqrt_in_place(&mut self) -> Option<&mut QuadExtField<P>>

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

fn mul_by_base_prime_field( &self, elem: &<QuadExtField<P> as Field>::BasePrimeField, ) -> QuadExtField<P>

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

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

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<P> From<bool> for QuadExtField<P>

where P: QuadExtConfig,

fn from(other: bool) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<i128> for QuadExtField<P>

where P: QuadExtConfig,

fn from(val: i128) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<i16> for QuadExtField<P>

where P: QuadExtConfig,

fn from(val: i16) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<i32> for QuadExtField<P>

where P: QuadExtConfig,

fn from(val: i32) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<i64> for QuadExtField<P>

where P: QuadExtConfig,

fn from(val: i64) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<i8> for QuadExtField<P>

where P: QuadExtConfig,

fn from(val: i8) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<u128> for QuadExtField<P>

where P: QuadExtConfig,

fn from(other: u128) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<u16> for QuadExtField<P>

where P: QuadExtConfig,

fn from(other: u16) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<u32> for QuadExtField<P>

where P: QuadExtConfig,

fn from(other: u32) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<u64> for QuadExtField<P>

where P: QuadExtConfig,

fn from(other: u64) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> From<u8> for QuadExtField<P>

where P: QuadExtConfig,

fn from(other: u8) -> QuadExtField<P>

Converts to this type from the input type.

impl<P> Hash for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: Hash,

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

where H: Hasher,

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<'a, 'b, P> Mul<&'a QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the * operator.

fn mul(self, other: &'a QuadExtField<P>) -> QuadExtField<P>

Performs the * operation.

impl<'a, P> Mul<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the * operator.

fn mul(self, other: &QuadExtField<P>) -> QuadExtField<P>

Performs the * operation.

impl<'a, 'b, P> Mul<&'a mut QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the * operator.

fn mul(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the * operation.

impl<'a, P> Mul<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the * operator.

fn mul(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the * operation.

impl<'b, P> Mul<QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the * operator.

fn mul(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the * operation.

impl<P> Mul for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the * operator.

fn mul(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the * operation.

impl<'a, P> MulAssign<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn mul_assign(&mut self, other: &QuadExtField<P>)

Performs the *= operation.

impl<'a, P> MulAssign<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn mul_assign(&mut self, other: &'a mut QuadExtField<P>)

Performs the *= operation.

impl<P> MulAssign for QuadExtField<P>

where P: QuadExtConfig,

fn mul_assign(&mut self, other: QuadExtField<P>)

Performs the *= operation.

impl<P> Neg for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the - operator.

fn neg(self) -> QuadExtField<P>

Performs the unary - operation.

impl<P> One for QuadExtField<P>

where P: QuadExtConfig,

fn one() -> QuadExtField<P>

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<P> Ord for QuadExtField<P>

where P: QuadExtConfig,

QuadExtField elements are ordered lexicographically.

fn cmp(&self, other: &QuadExtField<P>) -> 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,

Restrict a value to a certain interval.

impl<P> PartialEq for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: PartialEq,

fn eq(&self, other: &QuadExtField<P>) -> 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<P> PartialOrd for QuadExtField<P>

where P: QuadExtConfig,

fn partial_cmp(&self, other: &QuadExtField<P>) -> 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<'a, P> Product<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn product<I>(iter: I) -> QuadExtField<P>

where I: Iterator<Item = &'a QuadExtField<P>>,

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

impl<P> Product for QuadExtField<P>

where P: QuadExtConfig,

fn product<I>(iter: I) -> QuadExtField<P>

where I: Iterator<Item = QuadExtField<P>>,

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

impl<'a, 'b, P> Sub<&'a QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the - operator.

fn sub(self, other: &'a QuadExtField<P>) -> QuadExtField<P>

Performs the - operation.

impl<'a, P> Sub<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the - operator.

fn sub(self, other: &QuadExtField<P>) -> QuadExtField<P>

Performs the - operation.

impl<'a, 'b, P> Sub<&'a mut QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the - operator.

fn sub(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the - operation.

impl<'a, P> Sub<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the - operator.

fn sub(self, other: &'a mut QuadExtField<P>) -> QuadExtField<P>

Performs the - operation.

impl<'b, P> Sub<QuadExtField<P>> for &'b QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the - operator.

fn sub(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the - operation.

impl<P> Sub for QuadExtField<P>

where P: QuadExtConfig,

type Output = QuadExtField<P>

The resulting type after applying the - operator.

fn sub(self, other: QuadExtField<P>) -> QuadExtField<P>

Performs the - operation.

impl<'a, P> SubAssign<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn sub_assign(&mut self, other: &QuadExtField<P>)

Performs the -= operation.

impl<'a, P> SubAssign<&'a mut QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn sub_assign(&mut self, other: &'a mut QuadExtField<P>)

Performs the -= operation.

impl<P> SubAssign for QuadExtField<P>

where P: QuadExtConfig,

fn sub_assign(&mut self, other: QuadExtField<P>)

Performs the -= operation.

impl<'a, P> Sum<&'a QuadExtField<P>> for QuadExtField<P>

where P: QuadExtConfig,

fn sum<I>(iter: I) -> QuadExtField<P>

where I: Iterator<Item = &'a QuadExtField<P>>,

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

impl<P> Sum for QuadExtField<P>

where P: QuadExtConfig,

fn sum<I>(iter: I) -> QuadExtField<P>

where I: Iterator<Item = QuadExtField<P>>,

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

impl<P> ToConstraintField<<P as QuadExtConfig>::BasePrimeField> for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: ToConstraintField<<P as QuadExtConfig>::BasePrimeField>,

fn to_field_elements(&self) -> Option<Vec<<P as QuadExtConfig>::BasePrimeField>>

impl<P> Valid for QuadExtField<P>

where P: QuadExtConfig,

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

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

where Self: 'a,

impl<P> Zero for QuadExtField<P>

where P: QuadExtConfig,

fn zero() -> QuadExtField<P>

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.

impl<P> Zeroize for QuadExtField<P>

where P: QuadExtConfig,

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl<P> Copy for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: Copy,

impl<P> Eq for QuadExtField<P>

where P: QuadExtConfig, <P as QuadExtConfig>::BaseField: PartialEq,