Struct Fp 

pub struct Fp(/* private fields */);

An element of the Goldilocks field Fp = GF(p).

The wrapped u64 holds the value in Montgomery form (x * 2^64 mod p), always reduced into 0..p-1. Two Fp instances are equal iff their Montgomery limbs are equal, so PartialEq is correct and constant-time.

Implementations

impl Fp

pub const ZERO: Self

Additive identity.

pub const ONE: Self

Multiplicative identity.

pub const MINUS_ONE: Self

Element -1 mod p.

pub const fn from_u64_reduce(v: u64) -> Self

Build an element from a u64, reducing modulo p.

pub fn from_u64_canonical(v: u64) -> Option<Self>

Build an element from an already-canonical u64 (v < p); returns None otherwise.

pub const fn to_u64(self) -> u64

Return the canonical u64 representation in 0..p-1.

pub fn try_from_le_bytes(bytes: [u8; 8]) -> Option<Self>

Decode an element from 8 little-endian bytes.

Returns None if the encoded integer is not in canonical range (>= p).

pub fn to_le_bytes(self) -> [u8; 8]

Canonical 8-byte little-endian encoding.

pub const fn is_zero(self) -> bool

Test whether the element is zero.

pub const fn ct_eq(self, rhs: Self) -> u64

Constant-time equality: returns 0xFFFF_FFFF_FFFF_FFFF on equality, 0 otherwise.

pub const fn ct_select(mask: u64, a: Self, b: Self) -> Self

Branch-free select: returns a when mask == 0 and b when mask == u64::MAX. Behaviour for any other mask value is unspecified; the secret-scalar curve primitives only ever pass full-bit masks.

pub const fn square(self) -> Self

Squaring in Fp.

pub fn msquare(self, n: u32) -> Self

Repeated squaring: returns self^(2^n).

pub fn invert(self) -> Self

Multiplicative inverse via Fermat’s little theorem: x^(p-2).

Returns Fp::ZERO when called on zero (no panic), matching the “inverse-or-zero” convention used by the upstream reference impls.

pub fn pow(self, exp: u64) -> Self

Exponentiation by an unsigned 64-bit integer, via right-to-left square-and-multiply.

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

Square root in Fp.

Returns Some(s) such that s^2 == self when one exists (with the zero element returning Some(Self::ZERO)); returns None for non-squares. Picks one of the two roots: callers wanting a fixed sign must apply their own normalization on top.

Implementation is Tonelli-Shanks specialized to the Goldilocks p - 1 = 2^32 * (2^32 - 1) factorization, with the precomputed 2^32-th root-of-unity generator POWER_OF_TWO_GENERATOR standing in for z.

Trait Implementations

impl Add for Fp

type Output = Fp

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for Fp

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Fp

fn clone(&self) -> Fp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Fp

impl Debug for Fp

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

Formats the value using the given formatter.

impl Default for Fp

fn default() -> Self

Returns the “default value” for a type.

impl Eq for Fp

impl Hash for Fp

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 Fp

type Output = Fp

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for Fp

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for Fp

type Output = Fp

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for Fp

fn eq(&self, other: &Fp) -> 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 StructuralPartialEq for Fp

impl Sub for Fp

type Output = Fp

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for Fp

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.