Struct ark_ff :: fields :: models :: quadratic_extension :: QuadExtField Copy item path

impl<P: Fp2Config> QuadExtField<Fp2ConfigWrapper>

pub fn mul_assign_by_fp(&mut self, other: &P::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);

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

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

impl<P: Fp12Config> QuadExtField<Fp12ConfigWrapper>

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

pub fn mul_by_034( &mut self, c0: &Fp2<<::Fp6Config as Fp6Config>::Fp2Config>, c3: &Fp2<<::Fp6Config as Fp6Config>::Fp2Config>, c4: &Fp2<<::Fp6Config as Fp6Config>::Fp2Config> )

pub fn mul_by_014( &mut self, c0: &Fp2<<::Fp6Config as Fp6Config>::Fp2Config>, c1: &Fp2<<::Fp6Config as Fp6Config>::Fp2Config>, c4: &Fp2<<::Fp6Config as Fp6Config>::Fp2Config> )

impl<P: QuadExtConfig> QuadExtField

pub const fn new(c0: P::BaseField, c1: P::BaseField) -> Self

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 Self

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

pub fn norm(&self) -> P::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::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: QuadExtConfig> Add<&'a QuadExtField> for &'b QuadExtField

type Output = QuadExtField

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

type Output = QuadExtField

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

type Output = QuadExtField

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

type Output = QuadExtField

The resulting type after applying the + operator.

fn add(self, other: &'a mut Self) -> Self

Performs the + operation. Read more

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

type Output = QuadExtField

The resulting type after applying the + operator.

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

Performs the + operation. Read more

impl<P: QuadExtConfig> Add for QuadExtField

type Output = QuadExtField

The resulting type after applying the + operator.

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

Performs the + operation. Read more

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

fn add_assign(&mut self, other: &Self)

Performs the += operation. Read more

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

fn add_assign(&mut self, other: &'a mut Self)

Performs the += operation. Read more

impl<P: QuadExtConfig> AddAssign for QuadExtField

fn add_assign(&mut self, other: Self)

Performs the += operation. Read more

impl<P: QuadExtConfig> CanonicalDeserialize for QuadExtField

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

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<P: QuadExtConfig> CanonicalSerialize for QuadExtField

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

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 Clone for QuadExtField
where P: QuadExtConfig,

fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl Debug for QuadExtField
where P: QuadExtConfig,

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

Formats the value using the given formatter. Read more

impl Default for QuadExtField
where P: QuadExtConfig,

fn default() -> Self

Returns the “default value” for a type. Read more

impl<P: QuadExtConfig> Display for QuadExtField

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

Formats the value using the given formatter. Read more

impl<P: QuadExtConfig> Distribution<QuadExtField> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> QuadExtField

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>
where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness. Read more

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>
where F: Fn(T) -> S, Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more

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

type Output = QuadExtField

The resulting type after applying the / operator.

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

Performs the / operation. Read more

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

type Output = QuadExtField

The resulting type after applying the / operator.

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

Performs the / operation. Read more

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

type Output = QuadExtField

The resulting type after applying the / operator.

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

Performs the / operation. Read more

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

type Output = QuadExtField

The resulting type after applying the / operator.

fn div(self, other: &'a mut Self) -> Self

Performs the / operation. Read more

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

type Output = QuadExtField

The resulting type after applying the / operator.

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

Performs the / operation. Read more

impl<P: QuadExtConfig> Div for QuadExtField

type Output = QuadExtField

The resulting type after applying the / operator.

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

Performs the / operation. Read more

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

fn div_assign(&mut self, other: &Self)

Performs the /= operation. Read more

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

fn div_assign(&mut self, other: &'a mut Self)

Performs the /= operation. Read more

impl<P: QuadExtConfig> DivAssign for QuadExtField

fn div_assign(&mut self, other: Self)

Performs the /= operation. Read more

impl<P: QuadExtConfig> Field for QuadExtField

type BasePrimeField = ::BasePrimeField

type BasePrimeFieldIter = Chain<<::BaseField as Field>::BasePrimeFieldIter, <::BaseField as Field>::BasePrimeFieldIter>

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

Determines the algorithm for computing square roots.

const ZERO: Self = _

The additive identity of the field.

const ONE: Self = _

The multiplicative identity of the field.

fn extension_degree() -> u64

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

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

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

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 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 square(&self) -> Self

Returns self * self.

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. Read more

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

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

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 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<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 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: AsRef<[u64]>>(&self, exp: S) -> Self

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

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

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. Read more