Struct Limb 

#[repr(transparent)]
pub struct Limb(pub Word);

Big integers are represented as an array/vector of smaller CPU word-size integers called “limbs”.

The Limb type uses a 32-bit or 64-bit saturated representation, depending on the target. All bits of an inner Word are used to represent larger big integer types.

Tuple Fields

0: Word

Implementations

impl Limb

const fn bounded_div2k_mod_q( self, k: u32, k_upper_bound: u32, one_half_mod_q: Self, ) -> (Self, Self)

Compute self / 2^t mod q, returning the result, as well as the minimal factor f such that 2^t divides self + q·f.

Here, q := 2·one_half_mod_q + 1 is assumed odd and t := min(k, k_upper_bound).

Executes in variable time w.r.t. k_upper_bound only; executes in constant time w.r.t k.

impl Limb

pub const fn adc(self, rhs: Limb, carry: Limb) -> (Limb, Limb)

👎Deprecated since 0.7.0: please use carrying_add instead

Computes self + rhs + carry, returning the result along with the new carry.

pub const fn carrying_add(self, rhs: Limb, carry: Limb) -> (Limb, Limb)

Computes self + rhs + carry, returning the result along with the new carry.

pub const fn overflowing_add(self, rhs: Limb) -> (Limb, Limb)

Computes self + rhs, returning the result along with the carry.

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

Perform saturating addition.

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

Perform wrapping addition, discarding overflow.

impl Limb

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

Calculates a & b.

impl Limb

pub const fn not(self) -> Self

Calculates !a.

impl Limb

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

Calculates a | b.

impl Limb

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

Calculates a ^ b.

impl Limb

pub const fn bit(self, index: u32) -> Choice

Get the value of the bit at position index, as a truthy or falsy Choice. Returns the falsy value for indices out of range.

pub const fn bit_vartime(self, index: u32) -> bool

Returns true if the bit at position index is set, false for an unset bit or for indices out of range.

Remarks

This operation is variable time with respect to index only.

fn set_bit(self, index: u32, bit_value: Choice) -> Self

Sets the bit at index to 0 or 1 depending on the value of bit_value.

fn set_bit_vartime(self, index: u32, bit_value: bool) -> Self

Sets the bit at index to 0 or 1 depending on the value of bit_value, in variable-time with respect to index.

pub const fn bits(self) -> u32

Calculate the number of bits needed to represent this number.

pub const fn leading_zeros(self) -> u32

Calculate the number of leading zeros in the binary representation of this number.

pub const fn trailing_zeros(self) -> u32

Calculate the number of trailing zeros in the binary representation of this number.

pub const fn trailing_ones(self) -> u32

Calculate the number of trailing ones the binary representation of this number.

pub const fn restrict_bits(self, len: u32) -> Self

Clear bits at or above the given bit position.

impl Limb

pub fn is_odd(self) -> Choice

Is this limb an odd number?

pub fn cmp_vartime(self, other: Self) -> Ordering

Perform a comparison of the inner value in variable-time.

Note that the PartialOrd and Ord impls wrap constant-time comparisons using the subtle crate.

pub const fn eq_vartime(self, other: Self) -> bool

Performs an equality check in variable-time.

pub(crate) const fn is_nonzero(self) -> Choice

Returns the truthy value if self != 0 and the falsy value otherwise.

impl Limb

pub(crate) const fn select(a: Self, b: Self, c: Choice) -> Self

Return b if c is truthy, otherwise return a.

pub(crate) const fn ct_conditional_swap(a: &mut Self, b: &mut Self, c: Choice)

Swap the values of a and b if c is truthy, otherwise do nothing.

impl Limb

pub const fn div_rem(self, rhs: NonZero<Self>) -> (Limb, Limb)

Computes self / rhs, returning the quotient and remainder.

pub const fn div_rem_with_reciprocal(self, recip: &Reciprocal) -> (Limb, Limb)

Computes self / rhs where recip is a Reciprocal created from a non-zero Limb rhs. Returns the quotient and remainder.

pub const fn checked_div(self, rhs: Self) -> CtOption<Limb>

Computes the checked division self / rhs, returning the quotient if the divisor is non-zero, and CtOption::none() otherwise.

pub const fn checked_rem(self, rhs: Self) -> CtOption<Limb>

Computes the checked division self / rhs, returning the remainder if the divisor is non-zero, and CtOption::none() otherwise.

pub const fn div_exact(&self, rhs: NonZero<Limb>) -> CtOption<Self>

Exactly divides self by rhs, returning CtOption::none() if self is not divisible by rhs.

pub const fn div_exact_vartime(&self, rhs: NonZero<Limb>) -> CtOption<Self>

Exactly divides self by rhs, returning CtOption::none() if self is not divisible by rhs.

This is variable-time only with respect to rhs.

When used with a fixed rhs, this function is constant-time with respect to self.

impl Limb

pub const fn from_be_bytes(bytes: [u8; 8]) -> Self

Decode from big endian bytes.

pub const fn from_le_bytes(bytes: [u8; 8]) -> Self

Decode from little endian bytes.

pub const fn from_be_slice(bytes: &[u8]) -> Self

Decode limb from a big endian byte slice, which may be shorter than Limb::BYTES.

Panics

If the slice larger than Limb::BYTES.

pub const fn from_le_slice(bytes: &[u8]) -> Self

Decode limb from a little endian byte slice, which may be shorter than Limb::BYTES.

Panics

If the slice larger than Limb::BYTES.

pub const fn from_be_slice_truncated(bytes: &[u8], bits_precision: u32) -> Self

Decode limb from the provided big endian bytes, zero padding if necessary, and truncating to the least significant bytes in the event the given amount of data exceeds bits_precision.

Panics

If bits_precision > Self::BITS.

pub const fn from_le_slice_truncated(bytes: &[u8], bits_precision: u32) -> Self

Decode limb from the provided little endian bytes, zero padding if necessary, and truncating to the least significant bytes in the event the given amount of data exceeds bits_precision.

Panics

If bits_precision > Self::BITS.

pub const fn to_be_bytes(&self) -> [u8; 8]

Encode as big endian bytes.

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

Encode as little endian bytes.

pub(crate) const fn mask_to_precision(&mut self, bits_precision: u32)

Mask to the given number of bits precision.

impl Limb

pub const fn from_u8(n: u8) -> Self

Create a Limb from a u8 integer (const-friendly)

pub const fn from_u16(n: u16) -> Self

Create a Limb from a u16 integer (const-friendly)

pub const fn from_u32(n: u32) -> Self

Create a Limb from a u32 integer (const-friendly)

pub const fn from_u64(n: u64) -> Self

Create a Limb from a u64 integer (const-friendly)

impl Limb

pub const fn mac(self, b: Limb, c: Limb, carry: Limb) -> (Limb, Limb)

👎Deprecated since 0.7.0: please use carrying_mul_add instead (ordering of arguments changes)

Computes self + (b * c) + carry, returning the result along with the new carry.

pub const fn carrying_mul_add( self, rhs: Limb, addend: Limb, carry: Limb, ) -> (Limb, Limb)

Computes (self * rhs) + addend + carry, returning the result along with the new carry.

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

Perform saturating multiplication.

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

Perform wrapping multiplication, discarding overflow.

pub(crate) const fn widening_mul(self, rhs: Self) -> (Self, Self)

Compute “wide” multiplication, with a product twice the size of the input.

pub(crate) const fn widening_square(self) -> (Self, Self)

Compute “wide” squaring, with a product twice the size of the input.

pub(crate) const fn rem_wide(lo_hi: (Self, Self), p: NonZero<Self>) -> Self

Compute “wide” squaring, with a product twice the size of the input.

impl Limb

pub const fn wrapping_neg(self) -> Self

Perform wrapping negation.

impl Limb

pub const fn shl(self, shift: u32) -> Self

Computes self << shift.

Panics

• if shift overflows Limb::BITS.

pub const fn overflowing_shl(self, shift: u32) -> CtOption<Self>

Computes self << shift, returning CtOption::none() if the shift exceeds the capacity.

pub const fn overflowing_shl_vartime(self, shift: u32) -> Option<Self>

Computes self << shift, returning None if the shift exceeds the capacity.

This method is variable time in shift only.

pub const fn unbounded_shl(self, shift: u32) -> Self

Computes self << shift, returning Limb::ZERO if the shift exceeds the capacity.

pub const fn unbounded_shl_vartime(self, shift: u32) -> Self

Computes self << shift, returning Limb::ZERO if the shift exceeds the capacity.

This method is variable time in shift only.

pub const fn wrapping_shl(self, shift: u32) -> Self

Computes self << shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl Limb

pub const fn shr(self, shift: u32) -> Self

Computes self >> shift.

Panics

• if shift overflows Limb::BITS.

pub(crate) const fn shr1(self) -> (Self, Self)

Computes self >> 1 and return the result and the carry (0 or 1 << HI_BIT).

pub const fn overflowing_shr(self, shift: u32) -> CtOption<Self>

Computes self >> shift, returning CtOption::none() if the shift exceeds the capacity.

pub const fn overflowing_shr_vartime(self, shift: u32) -> Option<Self>

Computes self >> shift, returning None if the shift exceeds the capacity.

This method is variable time in shift only.

pub const fn unbounded_shr(self, shift: u32) -> Self

Computes self >> shift, returning Limb::ZERO if the shift exceeds the capacity.

pub const fn unbounded_shr_vartime(self, shift: u32) -> Self

Computes self >> shift, returning Limb::ZERO if the shift exceeds the capacity.

This method is variable time in shift only.

pub const fn wrapping_shr(self, shift: u32) -> Self

Computes self >> shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl Limb

pub const fn sbb(self, rhs: Limb, borrow: Limb) -> (Limb, Limb)

👎Deprecated since 0.7.0: please use borrowing_sub instead

Computes self - (rhs + borrow), returning the result along with the new borrow.

pub const fn borrowing_sub(self, rhs: Limb, borrow: Limb) -> (Limb, Limb)

Computes self - (rhs + borrow), returning the result along with the new borrow.

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

Perform saturating subtraction.

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

Perform wrapping subtraction, discarding underflow and wrapping around the boundary of the type.

impl Limb

pub const ZERO: Self

The value 0.

pub const ONE: Self

The value 1.

pub const MAX: Self

Maximum value this Limb can express.

pub(crate) const HI_BIT: u32

Highest bit in a Limb.

pub const BITS: u32 = 64

Size of the inner integer in bits.

pub const BYTES: usize = 8

Size of the inner integer in bytes.

pub const LOG2_BITS: u32

floor(log2(Self::BITS)).

pub const fn is_zero(&self) -> Choice

Is this limb equal to Limb::ZERO?

pub const fn to_nz(self) -> CtOption<NonZero<Self>>

Convert to a NonZero<Limb>.

Returns some if the original value is non-zero, and none otherwise.

pub(crate) const fn to_nz_or_one(self) -> (NonZero<Self>, Choice)

Convert to a NonZero<Limb>, defaulting to Self::ONE.

Returns a pair consisting of a NonZero<Limb>, and a Choice indicating whether the original value was non-zero (and preserved).

pub const fn lsb_to_choice(self) -> Choice

Convert the least significant bit of this Limb to a Choice.

pub const fn array_as_words<const N: usize>(array: &[Self; N]) -> &[Word; N]

Convert a shared reference to an array of Limbs into a shared reference to their inner Words for each limb.

pub const fn array_as_mut_words<const N: usize>( array: &mut [Self; N], ) -> &mut [Word; N]

Convert a mutable reference to an array of Limbs into a mutable reference to their inner Words for each limb.

pub const fn slice_as_words(slice: &[Self]) -> &[Word]

Convert a shared reference to an array of Limbs into a shared reference to their inner Words for each limb.

pub const fn slice_as_mut_words(slice: &mut [Self]) -> &mut [Word]

Convert a mutable reference to an array of Limbs into a mutable reference to their inner Words for each limb.

Trait Implementations

impl Add<&Limb> for Limb

type Output = Limb

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Limb

type Output = Limb

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Limb> for Limb

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

Performs the += operation.

impl AddAssign for Limb

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl AddMod for Limb

type Output = Limb

Output type.

fn add_mod(&self, rhs: &Self, p: &NonZero<Self>) -> Self::Output

Compute self + rhs mod p.

impl AsMut<[Limb]> for Limb

fn as_mut(&mut self) -> &mut [Limb]

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

impl AsMut<UintRef> for Limb

fn as_mut(&mut self) -> &mut UintRef

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

impl AsRef<[Limb]> for Limb

fn as_ref(&self) -> &[Limb]

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

impl AsRef<UintRef> for Limb

fn as_ref(&self) -> &UintRef

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

impl Binary for Limb

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

Formats the value using the given formatter.

impl BitAnd<&Limb> for Limb

type Output = Limb

The resulting type after applying the & operator.

fn bitand(self, rhs: &Self) -> Self::Output

Performs the & operation.

impl BitAnd for Limb

type Output = Limb

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAndAssign<&Limb> for Limb

fn bitand_assign(&mut self, rhs: &Limb)

Performs the &= operation.

impl BitAndAssign for Limb

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOps for Limb

fn bit(&self, index: u32) -> Choice

Get the value of the bit at position index, as a truthy or falsy Choice. Returns the falsy value for indices out of range.

fn bit_vartime(&self, index: u32) -> bool

Returns true if the bit at position index is set, false otherwise.

fn bits_precision(&self) -> u32

Precision of this integer in bits.

fn bits(&self) -> u32

Calculate the number of bits required to represent a given number.

fn bytes_precision(&self) -> usize

Precision of this integer in bytes.

fn leading_zeros(&self) -> u32

Calculate the number of leading zeros in the binary representation of this number.

fn log2_bits(&self) -> u32

floor(log2(self.bits_precision())).

fn set_bit(&mut self, index: u32, bit_value: Choice)

Sets the bit at index to 0 or 1 depending on the value of bit_value.

fn set_bit_vartime(&mut self, index: u32, bit_value: bool)

Sets the bit at index to 0 or 1 depending on the value of bit_value, variable time in self.

fn trailing_ones(&self) -> u32

Calculate the number of trailing ones in the binary representation of this number.

fn trailing_zeros(&self) -> u32

Calculate the number of trailing zeros in the binary representation of this number.

fn bits_vartime(&self) -> u32

Calculate the number of bits required to represent a given number in variable-time with respect to self.

fn leading_zeros_vartime(&self) -> u32

Calculate the number of leading zeros in the binary representation of this number.

fn trailing_zeros_vartime(&self) -> u32

Calculate the number of trailing zeros in the binary representation of this number in variable-time with respect to self.

fn trailing_ones_vartime(&self) -> u32

Calculate the number of trailing ones in the binary representation of this number, variable time in self.

impl BitOr<&Limb> for Limb

type Output = Limb

The resulting type after applying the | operator.

fn bitor(self, rhs: &Self) -> Self::Output

Performs the | operation.

impl BitOr for Limb

type Output = Limb

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign<&Limb> for Limb

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

Performs the |= operation.

impl BitOrAssign for Limb

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl BitXor<&Limb> for Limb

type Output = Limb

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &Self) -> Self::Output

Performs the ^ operation.

impl BitXor for Limb

type Output = Limb

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXorAssign<&Limb> for Limb

fn bitxor_assign(&mut self, rhs: &Self)

Performs the ^= operation.

impl BitXorAssign for Limb

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Bounded for Limb

const BITS: u32 = Self::BITS

Size of this integer in bits.

const BYTES: usize = Self::BYTES

Size of this integer in bytes.

impl CheckedAdd for Limb

fn checked_add(&self, rhs: &Self) -> CtOption<Self>

Perform checked addition, returning a CtOption which is_some only if the operation did not overflow.

impl CheckedDiv for Limb

fn checked_div(&self, rhs: &Self) -> CtOption<Self>

Perform checked division, returning a CtOption which is_some only if the divisor is non-zero.

impl CheckedMul for Limb

fn checked_mul(&self, rhs: &Self) -> CtOption<Self>

Perform checked multiplication, returning a CtOption which is_some only if the operation did not overflow.

impl CheckedSquareRoot for Limb

type Output = Limb

Output of the square root operation.

fn checked_sqrt(&self) -> CtOption<Self::Output>

Computes sqrt(self), returning none if no root exists.

fn checked_sqrt_vartime(&self) -> Option<Self::Output>

Computes sqrt(self), returning none if no root exists.

impl CheckedSub for Limb

fn checked_sub(&self, rhs: &Self) -> CtOption<Self>

Perform checked subtraction, returning a CtOption which is_some only if the operation did not underflow.

impl Clone for Limb

fn clone(&self) -> Limb

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConditionallySelectable for Limb

Available on crate feature subtle only.

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 ConstOne for Limb

const ONE: Self = Self::ONE

The multiplicative identity element of Self, 1.

impl ConstZero for Limb

const ZERO: Self = Self::ZERO

The additive identity element of Self, 0.

impl ConstantTimeEq for Limb

Available on crate feature subtle only.

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 ConstantTimeGreater for Limb

Available on crate feature subtle only.

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

Determine whether self > other.

impl ConstantTimeLess for Limb

Available on crate feature subtle only.

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

Determine whether self < other.

impl Constants for Limb

const MAX: Self = Self::MAX

Maximum value this integer can express.

impl CtAssign for Limb

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

Conditionally assign src to self if choice is Choice::TRUE.

impl CtAssignSlice for Limb

fn ct_assign_slice(dst: &mut [Self], src: &[Self], choice: Choice)

Conditionally assign src to dst if choice is Choice::TRUE, or leave it unchanged for Choice::FALSE.

impl CtEq for Limb

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

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

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

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

impl CtEqSlice for Limb

fn ct_eq_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is equal to b in constant-time.

fn ct_ne_slice(a: &[Self], b: &[Self]) -> Choice

Determine if a is NOT equal to b in constant-time.

impl CtGt for Limb

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

Compute whether self > other in constant time.

impl CtLt for Limb

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

Compute whether self < other in constant time.

impl CtSelect for Limb

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 Debug for Limb

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

Formats the value using the given formatter.

impl Default for Limb

fn default() -> Limb

Returns the “default value” for a type.

impl Display for Limb

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

Formats the value using the given formatter.

impl Div<&Limb> for &Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: &Limb) -> Limb

Performs the / operation.

impl Div<&Limb> for Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: &Limb) -> Self

Performs the / operation.

impl Div<&NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Limb>) -> Limb

Performs the / operation.

impl Div<&NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<Limb>) -> Self

Performs the / operation.

impl Div<Limb> for &Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: Limb) -> Limb

Performs the / operation.

impl Div<NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Limb>) -> Limb

Performs the / operation.

impl Div<NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<Limb>) -> Self

Performs the / operation.

impl Div for Limb

type Output = Limb

The resulting type after applying the / operator.

fn div(self, rhs: Limb) -> Self

Performs the / operation.

impl DivAssign<&Limb> for Limb

fn div_assign(&mut self, rhs: &Limb)

Performs the /= operation.

impl DivAssign<&NonZero<Limb>> for Limb

fn div_assign(&mut self, rhs: &NonZero<Limb>)

Performs the /= operation.

impl DivAssign<NonZero<Limb>> for Limb

fn div_assign(&mut self, rhs: NonZero<Limb>)

Performs the /= operation.

impl DivAssign for Limb

fn div_assign(&mut self, rhs: Limb)

Performs the /= operation.

impl DivRemLimb for Limb

fn div_rem_limb(&self, rhs: NonZero<Limb>) -> (Self, Limb)

Computes self / rhs using a pre-made reciprocal, returns the quotient (q) and remainder (r).

fn div_rem_limb_with_reciprocal(&self, rhs: &Reciprocal) -> (Self, Limb)

Computes self / rhs, returns the quotient (q) and remainder (r).

impl Encoding for Limb

type Repr = [u8; 8]

Byte array representation.

fn from_be_bytes(bytes: Self::Repr) -> Self

Decode from big endian bytes.

fn from_le_bytes(bytes: Self::Repr) -> Self

Decode from little endian bytes.

fn from_be_slice_truncated(bytes: &[u8], bits_precision: u32) -> Self

Decode from the provided big endian bytes, truncating to the least significant bits in the event the given amount of data exceeds bits_precision.

fn from_le_slice_truncated(bytes: &[u8], bits_precision: u32) -> Self

Decode from the provided little endian bytes, truncating to the least significant bits in the event the given amount of data exceeds bits_precision.

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

Encode to big endian bytes.

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

Encode to little endian bytes.

fn from_bytes(bytes: Self::Repr, byte_order: ByteOrder) -> Self

Decode from bytes using the specified ByteOrder.

fn from_slice_truncated( bytes: &[u8], bits_precision: u32, byte_order: ByteOrder, ) -> Self

Decode from the provided bytes, interpreting them using the specified ByteOrder, truncating to the least significant bits in the event the given amount of data exceeds bits_precision.

fn to_bytes(&self, byte_order: ByteOrder) -> Self::Repr

Encode to bytes using the specified ByteOrder.

impl FloorSquareRoot for Limb

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

Computes floor(sqrt(self)).

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

Computes floor(sqrt(self)).

impl From<Limb> for BoxedUint

fn from(limb: Limb) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<Limb> for Uint<LIMBS>

fn from(limb: Limb) -> Self

Converts to this type from the input type.

impl From<Limb> for WideWord

fn from(limb: Limb) -> WideWord

Converts to this type from the input type.

impl From<Limb> for Word

fn from(limb: Limb) -> Word

Converts to this type from the input type.

impl From<u16> for Limb

fn from(n: u16) -> Limb

Converts to this type from the input type.

impl From<u32> for Limb

fn from(n: u32) -> Limb

Converts to this type from the input type.

impl From<u64> for Limb

fn from(n: u64) -> Limb

Converts to this type from the input type.

impl From<u8> for Limb

fn from(n: u8) -> Limb

Converts to this type from the input type.

impl Gcd<Limb> for NonZero<Limb>

type Output = Limb

Output type.

fn gcd(&self, rhs: &Limb) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Limb) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl Gcd<Limb> for Odd<Limb>

type Output = Limb

Output type.

fn gcd(&self, rhs: &Limb) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Limb) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl Gcd for Limb

type Output = Limb

Output type.

fn gcd(&self, rhs: &Self) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Self) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl Hash for Limb

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 Integer for Limb

fn as_limbs(&self) -> &[Limb]

Borrow the raw limbs used to represent this integer.

fn as_mut_limbs(&mut self) -> &mut [Limb]

Mutably borrow the raw limbs used to represent this integer.

fn nlimbs(&self) -> usize

Number of limbs in this integer.

fn is_even(&self) -> Choice

Is this integer value an even number?

fn is_odd(&self) -> Choice

Is this integer value an odd number?

impl LowerHex for Limb

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

Formats the value using the given formatter.

impl Mul<&Limb> for &Limb

type Output = Limb

The resulting type after applying the * operator.

fn mul(self, rhs: &Limb) -> Self::Output

Performs the * operation.

impl Mul<&Limb> for Limb

type Output = Limb

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Limb> for &Limb

type Output = Limb

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Limb

type Output = Limb

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Limb> for Limb

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

Performs the *= operation.

impl MulAssign for Limb

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl MulMod for Limb

type Output = Limb

Output type.

fn mul_mod(&self, rhs: &Self, p: &NonZero<Self>) -> Self::Output

Compute self * rhs mod p.

impl NegMod for Limb

type Output = Limb

Output type.

fn neg_mod(&self, p: &NonZero<Self>) -> Self::Output

Compute -self mod p.

impl Not for Limb

type Output = Limb

The resulting type after applying the ! operator.

fn not(self) -> <Self as Not>::Output

Performs the unary ! operation.

impl Octal for Limb

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

Formats the value using the given formatter.

impl One for Limb

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> Choice

Determine if this value is equal to 1.

fn set_one(&mut self)

Set self to its multiplicative identity, i.e. Self::one.

fn one_like(_other: &Self) -> Self

Return the value 0 with the same precision as other.

impl One for Limb

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl Ord for Limb

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 PartialEq for Limb

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 PartialOrd for Limb

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 Random for Limb

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

Generate a random value.

fn random_from_rng<R: Rng + ?Sized>(rng: &mut R) -> Self

Generate a random value.

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

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

fn random() -> Self

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

impl RandomMod for Limb

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

Generate a random number which is less than a given modulus.

fn random_mod_vartime<R: Rng + ?Sized>( rng: &mut R, modulus: &NonZero<Self>, ) -> Self

Generate a random number which is less than a given modulus.

fn random_mod<R: Rng + ?Sized>(rng: &mut R, modulus: &NonZero<Self>) -> Self

👎Deprecated since 0.7.0: please use random_mod_vartime instead

Generate a random number which is less than a given modulus.

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

👎Deprecated since 0.7.0: please use try_random_mod_vartime instead

Generate a random number which is less than a given modulus.

impl Rem<&Limb> for &Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: &Limb) -> Limb

Performs the % operation.

impl Rem<&Limb> for Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: &Limb) -> Self

Performs the % operation.

impl Rem<&NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Limb>) -> Limb

Performs the % operation.

impl Rem<&NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<Limb>) -> Self

Performs the % operation.

impl Rem<Limb> for &Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: Limb) -> Limb

Performs the % operation.

impl Rem<NonZero<Limb>> for &Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Limb>) -> Limb

Performs the % operation.

impl Rem<NonZero<Limb>> for Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<Limb>) -> Self

Performs the % operation.

impl Rem for Limb

type Output = Limb

The resulting type after applying the % operator.

fn rem(self, rhs: Limb) -> Self

Performs the % operation.

impl RemAssign<&Limb> for Limb

fn rem_assign(&mut self, rhs: &Limb)

Performs the %= operation.

impl RemAssign<&NonZero<Limb>> for Limb

fn rem_assign(&mut self, rhs: &NonZero<Limb>)

Performs the %= operation.

impl RemAssign<NonZero<Limb>> for Limb

fn rem_assign(&mut self, rhs: NonZero<Limb>)

Performs the %= operation.

impl RemAssign for Limb

fn rem_assign(&mut self, rhs: Limb)

Performs the %= operation.

impl RemLimb for Limb

fn rem_limb(&self, rhs: NonZero<Limb>) -> Limb

Computes self % rhs using a pre-made reciprocal.

fn rem_limb_with_reciprocal(&self, rhs: &Reciprocal) -> Limb

Computes self % rhs.

impl Shl<i32> for &Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> Limb

Performs the << operation.

impl Shl<i32> for Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> Limb

Performs the << operation.

impl Shl<u32> for &Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> Limb

Performs the << operation.

impl Shl<u32> for Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> Limb

Performs the << operation.

impl Shl<usize> for &Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> Limb

Performs the << operation.

impl Shl<usize> for Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> Limb

Performs the << operation.

impl ShlAssign<i32> for Limb

fn shl_assign(&mut self, shift: i32)

Performs the <<= operation.

impl ShlAssign<u32> for Limb

fn shl_assign(&mut self, shift: u32)

Performs the <<= operation.

impl ShlAssign<usize> for Limb

fn shl_assign(&mut self, shift: usize)

Performs the <<= operation.

impl ShlVartime for Limb

fn overflowing_shl_vartime(&self, shift: u32) -> Option<Self>

Computes self << shift.

fn unbounded_shl_vartime(&self, shift: u32) -> Self

Computes self << shift.

fn wrapping_shl_vartime(&self, shift: u32) -> Self

Computes self << shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl Shr<i32> for &Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> Limb

Performs the >> operation.

impl Shr<i32> for Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> Limb

Performs the >> operation.

impl Shr<u32> for &Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> Limb

Performs the >> operation.

impl Shr<u32> for Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> Limb

Performs the >> operation.

impl Shr<usize> for &Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> Limb

Performs the >> operation.

impl Shr<usize> for Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> Limb

Performs the >> operation.

impl ShrAssign<i32> for Limb

fn shr_assign(&mut self, shift: i32)

Performs the >>= operation.

impl ShrAssign<u32> for Limb

fn shr_assign(&mut self, shift: u32)

Performs the >>= operation.

impl ShrAssign<usize> for Limb

fn shr_assign(&mut self, shift: usize)

Performs the >>= operation.

impl ShrVartime for Limb

fn overflowing_shr_vartime(&self, shift: u32) -> Option<Self>

Computes self >> shift.

fn unbounded_shr_vartime(&self, shift: u32) -> Self

Computes self >> shift.

fn wrapping_shr_vartime(&self, shift: u32) -> Self

Computes self >> shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl SquareMod for Limb

type Output = Limb

Output type.

fn square_mod(&self, p: &NonZero<Self>) -> Self::Output

Compute self * self mod p.

impl Sub<&Limb> for Limb

type Output = Limb

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Limb

type Output = Limb

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&Limb> for Limb

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.

impl SubAssign for Limb

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl SubMod for Limb

type Output = Limb

Output type.

fn sub_mod(&self, rhs: &Self, p: &NonZero<Self>) -> Self::Output

Compute self - rhs mod p.

impl Unsigned for Limb

fn as_uint_ref(&self) -> &UintRef

Borrow the limbs of this unsigned integer as a UintRef.

fn as_mut_uint_ref(&mut self) -> &mut UintRef

Mutably borrow the limbs of this unsigned integer as a UintRef.

fn from_limb_like(limb: Limb, _other: &Self) -> Self

Returns an integer with the first limb set to limb, and the same precision as other.

impl UpperHex for Limb

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

Formats the value using the given formatter.

impl WrappingAdd for Limb

fn wrapping_add(&self, v: &Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl WrappingMul for Limb

fn wrapping_mul(&self, v: &Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl WrappingNeg for Limb

fn wrapping_neg(&self) -> Self

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

impl WrappingShl for Limb

fn wrapping_shl(&self, shift: u32) -> Limb

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl WrappingShr for Limb

fn wrapping_shr(&self, shift: u32) -> Limb

Panic-free bitwise shift-right; yields self >> mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl WrappingSub for Limb

fn wrapping_sub(&self, v: &Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl Zero for Limb

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> Choice

Determine if this value is equal to 0.

fn set_zero(&mut self)

Set self to its additive identity, i.e. Self::zero.

fn zero_like(other: &Self) -> Self

where Self: Clone,

Return the value 0 with the same precision as other.

impl Zero for Limb

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Copy for Limb

impl DefaultIsZeroes for Limb

Available on crate feature zeroize only.

impl Eq for Limb

impl Sealed for Limb