Struct Scalar 

pub struct Scalar<C: CurveWithScalar> {
    pub(crate) scalar: U448,
    curve: PhantomData<C>,
}

Shared scalar for Ed448 and Decaf448. Use EdwardsScalar and DecafScalar directly.

This is the scalar field size = 4q = 2^446 - 0x8335dc163bb124b65129c96fde933d8d723a70aadc873d6d54a7bb0d We can therefore use 14 saturated 32-bit limbs

Fields

scalar: U448

curve: PhantomData<C>

Implementations

impl Scalar<Decaf448>

pub fn from_bytes_mod_order_wide(input: &WideDecafScalarBytes) -> DecafScalar

Construct a Scalar by reducing a 896-bit little-endian integer modulo the group order ℓ.

impl Scalar<Ed448>

pub fn to_bytes_rfc_8032(&self) -> EdwardsScalarBytes

Serialize the scalar into 57 bytes, per RFC 8032. Byte 56 will always be zero.

pub fn from_bytes_mod_order_wide( input: &WideEdwardsScalarBytes, ) -> EdwardsScalar

Construct a Scalar by reducing a 912-bit little-endian integer modulo the group order ℓ.

impl<C: CurveWithScalar> Scalar<C>

pub const ONE: Scalar<C>

The multiplicative identity element

pub const TWO: Scalar<C>

Twice the multiplicative identity element

pub const ZERO: Scalar<C>

The additive identity element

pub(crate) const fn new(scalar: U448) -> Self

pub const fn addition(&self, rhs: &Self) -> Self

Compute self + rhs mod ℓ

pub const fn double(&self) -> Self

Compute self + self mod ℓ

pub const fn subtract(&self, rhs: &Self) -> Self

Compute self - rhs mod ℓ

pub const fn multiply(&self, rhs: &Self) -> Self

Compute self * rhs mod ℓ

pub const fn square(&self) -> Self

Square this scalar

pub fn is_zero(&self) -> Choice

Is this scalar equal to zero?

pub(crate) fn to_radix_16(self) -> [i8; 113]

pub fn bits(&self) -> [bool; 448]

Returns the bits of the scalar in little-endian order.

pub fn to_bytes(&self) -> [u8; 56]

Convert this Scalar to a little-endian byte array.

pub fn invert(&self) -> Self

Invert this scalar

pub const fn exp_vartime(&self, exp: &[u64]) -> Self

Exponentiates self by exp, where exp is a little-endian order integer exponent.

pub fn sqrt(&self) -> CtOption<Self>

Return the square root of this scalar, if it is a quadratic residue.

pub fn div_by_2(&self) -> Self

Halves a Scalar modulo the prime

pub fn from_canonical_bytes( bytes: &Array<u8, <C as CurveWithScalar>::ReprSize>, ) -> CtOption<Self>

Attempt to construct a Scalar from a canonical byte representation.

Return

• Some(s), where s is the Scalar corresponding to bytes, if bytes is a canonical byte representation;
• None if bytes is not a canonical byte representation.

pub fn from_bytes_mod_order( input: &Array<u8, <C as CurveWithScalar>::ReprSize>, ) -> Scalar<C>

Construct a Scalar by reducing a 448-bit little-endian integer modulo the group order ℓ

pub fn random<R: Rng + CryptoRng>(rng: &mut R) -> Self

Return a Scalar chosen uniformly at random using a user-provided RNG.

Inputs

• rng: any RNG which implements the Rng + CryptoRng interface.

Returns

A random scalar within ℤ/lℤ.

Trait Implementations

impl<C: CurveWithScalar> Add<&Scalar<C>> for &Scalar<C>

type Output = Scalar<C>

The resulting type after applying the + operator.

fn add(self, rhs: &Scalar<C>) -> Self::Output

Performs the + operation.

impl<'b, C: CurveWithScalar> Add<&'b Scalar<C>> for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Scalar<C>) -> Scalar<C>

Performs the + operation.

impl<'a, C: CurveWithScalar> Add<Scalar<C>> for &'a Scalar<C>

type Output = Scalar<C>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<C>) -> Scalar<C>

Performs the + operation.

impl<C: CurveWithScalar> Add for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the + operator.

fn add(self, rhs: Scalar<C>) -> Scalar<C>

Performs the + operation.

impl<C: CurveWithScalar> AddAssign<&Scalar<C>> for Scalar<C>

fn add_assign(&mut self, rhs: &Scalar<C>)

Performs the += operation.

impl<C: CurveWithScalar> AddAssign for Scalar<C>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<C: CurveWithScalar> AsRef<Scalar<C>> for Scalar<C>

fn as_ref(&self) -> &Scalar<C>

Converts this type into a shared reference of the (usually inferred) input type.

impl<C: CurveWithScalar> Clone for Scalar<C>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<C: CurveWithScalar> ConditionallySelectable for Scalar<C>

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<C: CurveWithScalar> ConstantTimeEq for Scalar<C>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<C: CurveWithScalar> CtEq for Scalar<C>

fn ct_eq(&self, other: &Self) -> Choice

Determine if self is equal to other in constant-time.

fn ct_ne(&self, other: &Rhs) -> Choice

Determine if self is NOT equal to other in constant-time.

impl<C: CurveWithScalar> CtSelect for Scalar<C>

fn ct_select(&self, other: &Self, choice: Choice) -> Self

Select between self and other based on choice, returning a copy of the value.

fn ct_swap(&mut self, other: &mut Self, choice: Choice)

Conditionally swap self and other if choice is Choice::TRUE.

impl<C: CurveWithScalar> Debug for Scalar<C>

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

Formats the value using the given formatter.

impl<C: CurveWithScalar> Default for Scalar<C>

fn default() -> Self

Returns the “default value” for a type.

impl<C: CurveWithScalar> Display for Scalar<C>

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

Formats the value using the given formatter.

impl<C: CurveWithScalar> Field for Scalar<C>

const ZERO: Self = Self::ZERO

The zero element of the field, the additive identity.

const ONE: Self = Self::ONE

The one element of the field, the multiplicative identity.

fn try_random<R: TryRng + ?Sized>(rng: &mut R) -> Result<Self, R::Error>

Returns an element chosen uniformly at random using a user-provided fallible RNG.

fn square(&self) -> Self

Squares this element.

fn double(&self) -> Self

Doubles this element.

fn invert(&self) -> CtOption<Self>

Computes the multiplicative inverse of this element, failing if the element is zero.

fn sqrt_ratio(num: &Self, div: &Self) -> (Choice, Self)

Computes:

fn random<R>(rng: &mut R) -> Self

where R: Rng + ?Sized,

Returns an element chosen uniformly at random using a user-provided infallible RNG.

fn is_zero(&self) -> Choice

Returns true iff this element is zero.

fn is_zero_vartime(&self) -> bool

Returns true iff this element is zero.

fn cube(&self) -> Self

Cubes this element.

fn sqrt_alt(&self) -> (Choice, Self)

Equivalent to Self::sqrt_ratio(self, one()).

fn sqrt(&self) -> CtOption<Self>

Returns the square root of the field element, if it is quadratic residue.

fn pow<S>(&self, exp: S) -> Self

where S: AsRef<[u64]>,

Exponentiates self by exp, where exp is a little-endian order integer exponent.

fn pow_vartime<S>(&self, exp: S) -> Self

where S: AsRef<[u64]>,

Exponentiates self by exp, where exp is a little-endian order integer exponent.

impl<C: CurveWithScalar> From<&Scalar<C>> for Array<u8, <C as CurveWithScalar>::ReprSize>

fn from(scalar: &Scalar<C>) -> Array<u8, <C as CurveWithScalar>::ReprSize>

Converts to this type from the input type.

impl<C: CurveWithScalar> From<&Scalar<C>> for U448

fn from(scalar: &Scalar<C>) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> From<&Scalar<C>> for Vec<u8>

Available on crate feature alloc only.

fn from(scalar: &Scalar<C>) -> Vec<u8>

Converts to this type from the input type.

impl From<&Scalar<Decaf448>> for ScalarValue<Decaf448>

fn from(scalar: &DecafScalar) -> ScalarValue<Decaf448>

Converts to this type from the input type.

impl From<&Scalar<Ed448>> for ScalarValue<Ed448>

fn from(scalar: &EdwardsScalar) -> ScalarValue<Ed448>

Converts to this type from the input type.

impl<C: CurveWithScalar> From<&Uint<crypto_bigint::::uint::U448::{constant#0}>> for Scalar<C>

fn from(uint: &U448) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> From<Scalar<C>> for Array<u8, <C as CurveWithScalar>::ReprSize>

fn from(scalar: Scalar<C>) -> Array<u8, <C as CurveWithScalar>::ReprSize>

Converts to this type from the input type.

impl<C: CurveWithScalar> From<Scalar<C>> for U448

fn from(scalar: Scalar<C>) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> From<Scalar<C>> for Vec<u8>

Available on crate feature alloc only.

fn from(scalar: Scalar<C>) -> Vec<u8>

Converts to this type from the input type.

impl From<Scalar<Decaf448>> for ScalarValue<Decaf448>

fn from(scalar: DecafScalar) -> ScalarValue<Decaf448>

Converts to this type from the input type.

impl From<Scalar<Ed448>> for ScalarValue<Ed448>

fn from(scalar: EdwardsScalar) -> ScalarValue<Ed448>

Converts to this type from the input type.

impl<C: CurveWithScalar> From<Uint<crypto_bigint::::uint::U448::{constant#0}>> for Scalar<C>

fn from(uint: U448) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> From<u128> for Scalar<C>

fn from(a: u128) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> From<u16> for Scalar<C>

fn from(a: u16) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> From<u32> for Scalar<C>

fn from(a: u32) -> Scalar<C>

Converts to this type from the input type.

impl<C: CurveWithScalar> From<u64> for Scalar<C>

fn from(a: u64) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> From<u8> for Scalar<C>

fn from(a: u8) -> Self

Converts to this type from the input type.

impl<C: CurveWithScalar> FromUintUnchecked for Scalar<C>

type Uint = Uint<crypto_bigint::::uint::U448::{constant#0}>

Unsigned integer type (i.e. Curve::Uint)

fn from_uint_unchecked(uint: U448) -> Self

Instantiate scalar from an unsigned integer without checking whether the value overflows the field modulus.

impl<C: CurveWithScalar> Generate for Scalar<C>

fn try_generate_from_rng<R: TryCryptoRng + ?Sized>( rng: &mut R, ) -> Result<Self, R::Error>

Generate random key using the provided TryCryptoRng.

fn generate_from_rng<R>(rng: &mut R) -> Self

where R: CryptoRng + ?Sized,

Generate random key using the provided CryptoRng.

fn try_generate() -> Result<Self, Error>

Randomly generate a value of this type using the system’s ambient cryptographically secure random number generator.

fn generate() -> Self

Randomly generate a value of this type using the system’s ambient cryptographically secure random number generator.

impl<C: CurveWithScalar> Index<usize> for Scalar<C>

type Output = u64

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<C: CurveWithScalar> IndexMut<usize> for Scalar<C>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<C: CurveWithScalar> Invert for Scalar<C>

type Output = CtOption<Scalar<C>>

Output of the inversion.

fn invert(&self) -> CtOption<Self>

Computes the inverse.

fn invert_vartime(&self) -> Self::Output

Computes the inverse in variable-time.

impl<C: CurveWithScalar> IsHigh for Scalar<C>

fn is_high(&self) -> Choice

Is this scalar greater than n / 2?

impl<C: CurveWithScalar> LowerHex for Scalar<C>

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

Formats the value using the given formatter.

impl<C: CurveWithScalar> Mul<&Scalar<C>> for &Scalar<C>

type Output = Scalar<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<C>) -> Self::Output

Performs the * operation.

impl<'b, C: CurveWithScalar> Mul<&'b Scalar<C>> for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Scalar<C>) -> Scalar<C>

Performs the * operation.

impl Mul<&Scalar<Decaf448>> for &AffinePoint

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, scalar: &DecafScalar) -> DecafPoint

Performs the * operation.

impl Mul<&Scalar<Decaf448>> for &DecafPoint

Scalar Mul Operations

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, scalar: &DecafScalar) -> DecafPoint

Performs the * operation.

impl<'b> Mul<&'b Scalar<Decaf448>> for AffinePoint

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, rhs: &'b DecafScalar) -> DecafPoint

Performs the * operation.

impl<'b> Mul<&'b Scalar<Decaf448>> for DecafPoint

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, rhs: &'b DecafScalar) -> DecafPoint

Performs the * operation.

impl Mul<&Scalar<Ed448>> for &AffinePoint

type Output = EdwardsPoint

The resulting type after applying the * operator.

fn mul(self, scalar: &EdwardsScalar) -> Self::Output

Performs the * operation.

impl Mul<&Scalar<Ed448>> for &EdwardsPoint

fn mul(self, scalar: &EdwardsScalar) -> EdwardsPoint

Scalar multiplication: compute scalar * self.

type Output = EdwardsPoint

The resulting type after applying the * operator.

impl Mul<&Scalar<Ed448>> for &MontgomeryPoint

type Output = MontgomeryPoint

The resulting type after applying the * operator.

fn mul(self, scalar: &EdwardsScalar) -> MontgomeryPoint

Performs the * operation.

impl<'b> Mul<&'b Scalar<Ed448>> for AffinePoint

type Output = EdwardsPoint

The resulting type after applying the * operator.

fn mul(self, rhs: &'b EdwardsScalar) -> EdwardsPoint

Performs the * operation.

impl<'b> Mul<&'b Scalar<Ed448>> for EdwardsPoint

type Output = EdwardsPoint

The resulting type after applying the * operator.

fn mul(self, rhs: &'b EdwardsScalar) -> EdwardsPoint

Performs the * operation.

impl<'a, C: CurveWithScalar> Mul<Scalar<C>> for &'a Scalar<C>

type Output = Scalar<C>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<C>) -> Scalar<C>

Performs the * operation.

impl<'a> Mul<Scalar<Decaf448>> for &'a AffinePoint

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, rhs: DecafScalar) -> DecafPoint

Performs the * operation.

impl<'a> Mul<Scalar<Decaf448>> for &'a DecafPoint

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, rhs: DecafScalar) -> DecafPoint

Performs the * operation.

impl Mul<Scalar<Decaf448>> for AffinePoint

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, rhs: DecafScalar) -> DecafPoint

Performs the * operation.

impl Mul<Scalar<Decaf448>> for DecafPoint

type Output = DecafPoint

The resulting type after applying the * operator.

fn mul(self, rhs: DecafScalar) -> DecafPoint

Performs the * operation.

impl<'a> Mul<Scalar<Ed448>> for &'a AffinePoint

type Output = EdwardsPoint

The resulting type after applying the * operator.

fn mul(self, rhs: EdwardsScalar) -> EdwardsPoint

Performs the * operation.

impl<'a> Mul<Scalar<Ed448>> for &'a EdwardsPoint

type Output = EdwardsPoint

The resulting type after applying the * operator.

fn mul(self, rhs: EdwardsScalar) -> EdwardsPoint

Performs the * operation.

impl Mul<Scalar<Ed448>> for AffinePoint

type Output = EdwardsPoint

The resulting type after applying the * operator.

fn mul(self, rhs: EdwardsScalar) -> EdwardsPoint

Performs the * operation.

impl Mul<Scalar<Ed448>> for EdwardsPoint

type Output = EdwardsPoint

The resulting type after applying the * operator.

fn mul(self, rhs: EdwardsScalar) -> EdwardsPoint

Performs the * operation.

impl<C: CurveWithScalar> Mul for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<C>) -> Scalar<C>

Performs the * operation.

impl<C: CurveWithScalar> MulAssign<&Scalar<C>> for Scalar<C>

fn mul_assign(&mut self, rhs: &Scalar<C>)

Performs the *= operation.

impl<'s> MulAssign<&'s Scalar<Decaf448>> for DecafPoint

fn mul_assign(&mut self, scalar: &'s DecafScalar)

Performs the *= operation.

impl<'b> MulAssign<&'b Scalar<Ed448>> for EdwardsPoint

fn mul_assign(&mut self, scalar: &'b EdwardsScalar)

Performs the *= operation.

impl MulAssign<Scalar<Decaf448>> for DecafPoint

fn mul_assign(&mut self, scalar: DecafScalar)

Performs the *= operation.

impl MulAssign<Scalar<Ed448>> for EdwardsPoint

fn mul_assign(&mut self, rhs: EdwardsScalar)

Performs the *= operation.

impl<C: CurveWithScalar> MulAssign for Scalar<C>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulVartime<&Scalar<Decaf448>> for &AffinePoint

fn mul_vartime(self, scalar: &DecafScalar) -> DecafPoint

Multiply self by rhs in variable-time.

impl MulVartime<&Scalar<Decaf448>> for &DecafPoint

fn mul_vartime(self, scalar: &DecafScalar) -> DecafPoint

Multiply self by rhs in variable-time.

impl MulVartime<&Scalar<Decaf448>> for AffinePoint

fn mul_vartime(self, scalar: &DecafScalar) -> DecafPoint

Multiply self by rhs in variable-time.

impl MulVartime<&Scalar<Decaf448>> for DecafPoint

fn mul_vartime(self, scalar: &DecafScalar) -> DecafPoint

Multiply self by rhs in variable-time.

impl MulVartime<&Scalar<Ed448>> for &AffinePoint

fn mul_vartime(self, scalar: &EdwardsScalar) -> Self::Output

Multiply self by rhs in variable-time.

impl MulVartime<&Scalar<Ed448>> for &EdwardsPoint

fn mul_vartime(self, scalar: &EdwardsScalar) -> EdwardsPoint

Multiply self by rhs in variable-time.

impl MulVartime<&Scalar<Ed448>> for AffinePoint

fn mul_vartime(self, scalar: &EdwardsScalar) -> Self::Output

Multiply self by rhs in variable-time.

impl MulVartime<&Scalar<Ed448>> for EdwardsPoint

fn mul_vartime(self, scalar: &EdwardsScalar) -> EdwardsPoint

Multiply self by rhs in variable-time.

impl MulVartime<Scalar<Decaf448>> for AffinePoint

fn mul_vartime(self, scalar: DecafScalar) -> DecafPoint

Multiply self by rhs in variable-time.

impl MulVartime<Scalar<Decaf448>> for DecafPoint

fn mul_vartime(self, scalar: DecafScalar) -> DecafPoint

Multiply self by rhs in variable-time.

impl MulVartime<Scalar<Ed448>> for AffinePoint

fn mul_vartime(self, scalar: EdwardsScalar) -> Self::Output

Multiply self by rhs in variable-time.

impl MulVartime<Scalar<Ed448>> for EdwardsPoint

fn mul_vartime(self, scalar: EdwardsScalar) -> EdwardsPoint

Multiply self by rhs in variable-time.

impl<C: CurveWithScalar> Neg for &Scalar<C>

type Output = Scalar<C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<C: CurveWithScalar> Neg for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<C: CurveWithScalar> Ord for Scalar<C>

fn cmp(&self, other: &Self) -> 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<C: CurveWithScalar> PartialEq for Scalar<C>

fn eq(&self, other: &Scalar<C>) -> 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<C: CurveWithScalar> PartialOrd for Scalar<C>

fn partial_cmp(&self, other: &Self) -> 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<C: CurveWithScalar> PrimeField for Scalar<C>

const MODULUS: &'static str = "3fffffffffffffffffffffffffffffffffffffffffffffffffffffff7cca23e9c44edb49aed63690216cc2728dc58f552378c292ab5844f3"

Modulus of the field written as a string for debugging purposes.

const NUM_BITS: u32 = 446

How many bits are needed to represent an element of this field.

const CAPACITY: u32

How many bits of information can be reliably stored in the field element.

const TWO_INV: Self

Inverse of $2$ in the field.

const MULTIPLICATIVE_GENERATOR: Self

A fixed multiplicative generator of modulus - 1 order. This element must also be a quadratic nonresidue.

const S: u32 = 1

An integer s satisfying the equation 2^s * t = modulus - 1 with t odd.

const ROOT_OF_UNITY: Self

The 2^s root of unity.

const ROOT_OF_UNITY_INV: Self

Inverse of Self::ROOT_OF_UNITY.

const DELTA: Self

Generator of the t-order multiplicative subgroup.

type Repr = Array<u8, <C as CurveWithScalar>::ReprSize>

The prime field can be converted back and forth into this binary representation.

fn from_repr(repr: Self::Repr) -> CtOption<Self>

Attempts to convert a byte representation of a field element into an element of this prime field, failing if the input is not canonical (is not smaller than the field’s modulus).

fn to_repr(&self) -> Self::Repr

Converts an element of the prime field into the standard byte representation for this field.

fn is_odd(&self) -> Choice

Returns true iff this element is odd.

fn from_str_vartime(s: &str) -> Option<Self>

Interpret a string of numbers as a (congruent) prime field element. Does not accept unnecessary leading zeroes or a blank string.

fn from_u128(v: u128) -> Self

Obtains a field element congruent to the integer v.

fn from_repr_vartime(repr: Self::Repr) -> Option<Self>

Attempts to convert a byte representation of a field element into an element of this prime field, failing if the input is not canonical (is not smaller than the field’s modulus).

fn is_even(&self) -> Choice

Returns true iff this element is even.

impl<'a, C: CurveWithScalar> Product<&'a Scalar<C>> for Scalar<C>

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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

impl<C: CurveWithScalar> Product for Scalar<C>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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

impl<C: CurveWithScalar> Reduce<Array<u8, <C as CurveWithScalar>::ReprSize>> for Scalar<C>

fn reduce(bytes: &Array<u8, <C as CurveWithScalar>::ReprSize>) -> Self

Reduces self modulo Modulus.

impl<C: CurveWithScalar> Reduce<Uint<crypto_bigint::::uint::U448::{constant#0}>> for Scalar<C>

fn reduce(bytes: &U448) -> Self

Reduces self modulo Modulus.

impl<C: CurveWithScalar> Reduce<Uint<crypto_bigint::::uint::U896::{constant#0}>> for Scalar<C>

fn reduce(bytes: &U896) -> Self

Reduces self modulo Modulus.

impl<C: CurveWithScalar> ReduceNonZero<Array<u8, <C as CurveWithScalar>::ReprSize>> for Scalar<C>

fn reduce_nonzero(bytes: &Array<u8, <C as CurveWithScalar>::ReprSize>) -> Self

Perform a modular reduction, returning a field element.

impl<C: CurveWithScalar> ReduceNonZero<Uint<crypto_bigint::::uint::U448::{constant#0}>> for Scalar<C>

fn reduce_nonzero(bytes: &U448) -> Self

Perform a modular reduction, returning a field element.

impl<C: CurveWithScalar> ReduceNonZero<Uint<crypto_bigint::::uint::U896::{constant#0}>> for Scalar<C>

fn reduce_nonzero(bytes: &U896) -> Self

Perform a modular reduction, returning a field element.

impl<C: CurveWithScalar> Retrieve for Scalar<C>

type Output = Uint<crypto_bigint::::uint::U448::{constant#0}>

The original type.

fn retrieve(&self) -> U448

Convert the number back from the optimized representation.

impl<C: CurveWithScalar> Shr<usize> for &Scalar<C>

type Output = Scalar<C>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl<C: CurveWithScalar> Shr<usize> for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation.

impl<C: CurveWithScalar> ShrAssign<usize> for Scalar<C>

fn shr_assign(&mut self, shift: usize)

Performs the >>= operation.

impl<C: CurveWithScalar> Sub<&Scalar<C>> for &Scalar<C>

type Output = Scalar<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &Scalar<C>) -> Self::Output

Performs the - operation.

impl<'b, C: CurveWithScalar> Sub<&'b Scalar<C>> for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Scalar<C>) -> Scalar<C>

Performs the - operation.

impl<'a, C: CurveWithScalar> Sub<Scalar<C>> for &'a Scalar<C>

type Output = Scalar<C>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<C>) -> Scalar<C>

Performs the - operation.

impl<C: CurveWithScalar> Sub for Scalar<C>

type Output = Scalar<C>

The resulting type after applying the - operator.

fn sub(self, rhs: Scalar<C>) -> Scalar<C>

Performs the - operation.

impl<C: CurveWithScalar> SubAssign<&Scalar<C>> for Scalar<C>

fn sub_assign(&mut self, rhs: &Scalar<C>)

Performs the -= operation.

impl<C: CurveWithScalar> SubAssign for Scalar<C>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a, C: CurveWithScalar> Sum<&'a Scalar<C>> for Scalar<C>

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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

impl<C: CurveWithScalar> Sum for Scalar<C>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

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

impl<C: CurveWithScalar> TryFrom<&[u8]> for Scalar<C>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl<C: CurveWithScalar> TryFrom<&Vec<u8>> for Scalar<C>

Available on crate feature alloc only.

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(bytes: &Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.

impl<C: CurveWithScalar> TryFrom<Box<[u8]>> for Scalar<C>

Available on crate feature alloc only.

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(bytes: Box<[u8]>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Scalar<Decaf448>> for NonZeroScalar<Decaf448>

The constant-time alternative is available at elliptic_curve::NonZeroScalar<Decaf448>::new().

type Error = Error

The type returned in the event of a conversion error.

fn try_from(scalar: DecafScalar) -> Result<Self>

Performs the conversion.

impl TryFrom<Scalar<Ed448>> for NonZeroScalar<Ed448>

The constant-time alternative is available at elliptic_curve::NonZeroScalar<Ed448>::new().

type Error = Error

The type returned in the event of a conversion error.

fn try_from(scalar: EdwardsScalar) -> Result<Self>

Performs the conversion.

impl<C: CurveWithScalar> TryFrom<Vec<u8>> for Scalar<C>

Available on crate feature alloc only.

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error>

Performs the conversion.

impl<C: CurveWithScalar> UpperHex for Scalar<C>

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

Formats the value using the given formatter.

impl<C: CurveWithScalar> Copy for Scalar<C>

impl<C: CurveWithScalar> DefaultIsZeroes for Scalar<C>

impl<C: CurveWithScalar> Eq for Scalar<C>