Struct ark_bls12_381::FrConfig

pub struct FrConfig;

Trait Implementations

impl MontConfig<4> for FrConfig

fn neg_in_place(a: &mut Fp<MontBackend<FrConfig, { _ }>, { _ }>)

Sets a = -a.

const MODULUS: BigInt<{ _ }> = _

The modulus of the field.

const GENERATOR: Fp<MontBackend<FrConfig, { _ }>, { _ }> = _

A multiplicative generator of the field. Self::GENERATOR is an element having multiplicative order Self::MODULUS - 1.

const TWO_ADIC_ROOT_OF_UNITY: Fp<MontBackend<FrConfig, { _ }>, { _ }> = _

2^s root of unity computed by GENERATOR^t

const SMALL_SUBGROUP_BASE: Option<u32> = _

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> = _

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

const LARGE_SUBGROUP_ROOT_OF_UNITY: Option<Fp<MontBackend<FrConfig, { _ }>, { _ }>> = _

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

fn add_assign(
    a: &mut Fp<MontBackend<FrConfig, { _ }>, { _ }>,
    b: &Fp<MontBackend<FrConfig, { _ }>, { _ }>
)

Sets a = a + b.

fn sub_assign(
    a: &mut Fp<MontBackend<FrConfig, { _ }>, { _ }>,
    b: &Fp<MontBackend<FrConfig, { _ }>, { _ }>
)

Sets a = a - b.

fn double_in_place(a: &mut Fp<MontBackend<FrConfig, { _ }>, { _ }>)

Sets a = 2 * a.

fn mul_assign(
    a: &mut Fp<MontBackend<FrConfig, { _ }>, { _ }>,
    b: &Fp<MontBackend<FrConfig, { _ }>, { _ }>
)

This modular multiplication algorithm uses Montgomery reduction for efficient implementation. It also additionally uses the “no-carry optimization” outlined here if Self::MODULUS has (a) a non-zero MSB, and (b) at least one zero bit in the rest of the modulus.

fn square_in_place(a: &mut Fp<MontBackend<FrConfig, { _ }>, { _ }>)

fn sum_of_products<const M: usize>(
    a: &[Fp<MontBackend<FrConfig, { _ }>, { _ }>; M],
    b: &[Fp<MontBackend<FrConfig, { _ }>, { _ }>; M]
) -> Fp<MontBackend<FrConfig, { _ }>, { _ }>

const R: BigInt<N> = Self::MODULUS.montgomery_r()

Let M be the power of 2^64 nearest to Self::MODULUS_BITS. Then R = M % Self::MODULUS.

const R2: BigInt<N> = Self::MODULUS.montgomery_r2()

R2 = R^2 % Self::MODULUS

const INV: u64 = inv::<Self, N>()

INV = -MODULUS^{-1} mod 2^64

const SQRT_PRECOMP: Option<SqrtPrecomputation<Fp<MontBackend<Self, N>, N>>> = sqrt_precomputation::<N, Self>()

Precomputed material for use when computing square roots. The default is to use the standard Tonelli-Shanks algorithm.

fn inverse(
    a: &Fp<MontBackend<Self, N>, N>
) -> Option<Fp<MontBackend<Self, N>, N>>

fn from_bigint(r: BigInt<N>) -> Option<Fp<MontBackend<Self, N>, N>>

fn into_bigint(a: Fp<MontBackend<Self, N>, N>) -> BigInt<N>