Struct SmallFq 

pub struct SmallFq<P> {
    p: P,
    d: u32,
    q: u32,
    table: &'static [SmallFqElement],
}

A field of order q = p^d, where q < 2^16 and d > 1. Fields of that size are small enough that we can cache their Zech logarithms.

Note: This populates the Zech logarithm table eagerly, which can be rather expensive (several milliseconds). Only construct these fields if you’re going to use them.

Fields

p: P

d: u32

q: u32

table: &'static [SmallFqElement]

Implementations

impl<P: Prime> SmallFq<P>

pub fn new(p: P, d: u32) -> Self

pub fn negative_one(self) -> FieldElement<Self>

Return the element -1. If p = 2, this is a^0 = 1. Otherwise, it is a^((q - 1) / 2).

pub fn a(self) -> FieldElement<Self>

The distinguished primitive element that generates the multiplicative group of the field.

Trait Implementations

impl<P: Prime> Arbitrary for SmallFq<P>

Available on crate feature proptest only.

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

type Strategy = BoxedStrategy<SmallFq<P>>

The type of Strategy used to generate values of type Self.

fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

impl<P: Clone> Clone for SmallFq<P>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P: Prime> Debug for SmallFq<P>

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

Formats the value using the given formatter.

impl<P: Prime> Display for SmallFq<P>

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

Formats the value using the given formatter.

impl<P: Prime> Field for SmallFq<P>

type Characteristic = P

fn characteristic(self) -> Self::Characteristic

fn degree(self) -> u32

fn q(self) -> u32

fn zero(self) -> FieldElement<Self>

fn one(self) -> FieldElement<Self>

fn arb_element(self) -> impl Strategy<Value = FieldElement<Self>>

impl<P: Prime> FieldInternal for SmallFq<P>

fn encode(self, element: FieldElement<Self>) -> u64

This is 2n + 1 if element is a^n, and 0 otherwise.

type ElementContainer = SmallFqElement

The internal representation of a field element.

fn el(self, value: Self::ElementContainer) -> FieldElement<Self>

Create a new field element. This is the method responsible for ensuring that the returned value is in a consistent state. For example, for a prime field of characteristic p, this function is responsible for ensuring that the FieldElement that is returned contains a value in the range 0..p.

fn add_assign(self, a: &mut FieldElement<Self>, b: FieldElement<Self>)

fn add(self, a: FieldElement<Self>, b: FieldElement<Self>) -> FieldElement<Self>

fn mul_assign(self, a: &mut FieldElement<Self>, b: FieldElement<Self>)

fn neg(self, a: FieldElement<Self>) -> FieldElement<Self>

fn inv(self, a: FieldElement<Self>) -> Option<FieldElement<Self>>

fn frobenius(self, a: FieldElement<Self>) -> FieldElement<Self>

fn decode(self, element: u64) -> FieldElement<Self>

Decode a Limb into a field element. The argument will always contain a single encoded field element, padded with zeros. This is the inverse of encode.

fn bit_length(self) -> usize

Return the number of bits a Self::Element occupies in a limb.

fn fma_limb(self, limb_a: u64, limb_b: u64, coeff: FieldElement<Self>) -> u64

Fused multiply-add. Return the Limb whose ith entry is limb_a[i] + coeff * limb_b[i]. Both limb_a and limb_b are assumed to be reduced, and the result does not have to be reduced.

fn reduce(self, limb: u64) -> u64

Reduce a limb, i.e. make it “canonical”. For example, in Fp, this replaces every entry by its value modulo p.

fn sub_assign(self, a: &mut FieldElement<Self>, b: FieldElement<Self>)

fn sub(self, a: FieldElement<Self>, b: FieldElement<Self>) -> FieldElement<Self>

fn mul(self, a: FieldElement<Self>, b: FieldElement<Self>) -> FieldElement<Self>

fn div( self, a: FieldElement<Self>, b: FieldElement<Self>, ) -> Option<FieldElement<Self>>

fn bitmask(self) -> u64

If l is a limb of Self::Elements, then l & F.bitmask() is the value of the first entry of l.

fn entries_per_limb(self) -> usize

The number of Self::Elements that fit in a single limb.

fn limb_bit_index_pair(self, idx: usize) -> LimbBitIndexPair

fn is_reduced(self, limb: u64) -> bool

Check whether or not a limb is reduced. This may potentially not be faster than calling reduce directly.

fn pack<T: Iterator<Item = FieldElement<Self>>>(self, entries: T) -> u64

Given an interator of FieldElement<Self>s, pack all of them into a single limb in order. It is assumed that the values of the iterator fit into a single limb. If this assumption is violated, the result will be nonsense.

fn unpack(self, limb: u64) -> LimbIterator<Self>

Give an iterator over the entries of limb.

fn number(self, dim: usize) -> usize

Return the number of limbs required to hold dim entries.

fn range(self, start: usize, end: usize) -> Range<usize>

Return the Range<usize> starting at the index of the limb containing the startth entry, and ending at the index of the limb containing the endth entry (including the latter).

fn truncate(self, sum: u64) -> Option<u64>

Return either Some(sum) if no carries happen in the limb, or None if some carry does happen.

impl<P: Prime> Hash for SmallFq<P>

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<P: Prime> PartialEq for SmallFq<P>

fn eq(&self, other: &Self) -> 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: Copy> Copy for SmallFq<P>

impl<P: Prime> Eq for SmallFq<P>

impl<P: Prime> MaybeArbitrary<()> for SmallFq<P>