Struct Limb 

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

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

Tuple Fields

0: u64

Implementations

impl Limb

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

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

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

Perform saturating addition.

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

Perform wrapping addition, discarding overflow.

impl Limb

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

Calculates a & b.

impl Limb

pub const fn not(self) -> Limb

Calculates !a.

impl Limb

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

Calculates a | b.

impl Limb

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

Calculates a ^ b.

impl Limb

pub const fn bits(self) -> usize

Calculate the number of bits needed to represent this number.

pub const fn leading_zeros(self) -> usize

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

pub const fn trailing_zeros(self) -> usize

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

pub const fn trailing_ones(self) -> usize

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

impl Limb

pub fn is_odd(&self) -> Choice

Is this limb an odd number?

pub fn cmp_vartime(&self, other: &Limb) -> 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: &Limb) -> bool

Performs an equality check in variable-time.

impl Limb

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

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

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

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

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

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

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

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

impl Limb

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

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

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

Perform saturating multiplication.

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

Perform wrapping multiplication, discarding overflow.

impl Limb

pub const fn wrapping_neg(self) -> Limb

Perform wrapping negation.

impl Limb

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

Computes self << rhs. Panics if rhs overflows Limb::BITS.

impl Limb

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

Computes self >> rhs. Panics if rhs overflows Limb::BITS.

impl Limb

pub const fn sbb(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: Limb) -> Limb

Perform saturating subtraction.

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

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

impl Limb

pub const ZERO: Limb

The value 0.

pub const ONE: Limb

The value 1.

pub const MAX: Limb

Maximum value this Limb can express.

pub const BITS: usize = 64

Size of the inner integer in bits.

pub const BYTES: usize = 8

Size of the inner integer in bytes.

Trait Implementations

impl BitAnd for Limb

type Output = Limb

The resulting type after applying the & operator.

fn bitand(self, rhs: Limb) -> <Limb as BitAnd>::Output

Performs the & operation.

impl BitOr for Limb

type Output = Limb

The resulting type after applying the | operator.

fn bitor(self, rhs: Limb) -> <Limb as BitOr>::Output

Performs the | operation.

impl BitXor for Limb

type Output = Limb

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Limb) -> <Limb as BitXor>::Output

Performs the ^ operation.

impl Bounded for Limb

const BITS: usize = Self::BITS

Size of this integer in bits.

const BYTES: usize = Self::BYTES

Size of this integer in bytes.

impl CheckedAdd for Limb

type Output = Limb

Output type.

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

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

impl CheckedMul for Limb

type Output = Limb

Output type.

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

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

impl CheckedSub for Limb

type Output = Limb

Output type.

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

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

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

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

fn ct_eq(&self, other: &Limb) -> 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

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

Determine whether self > other.

impl ConstantTimeLess for Limb

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

Determine whether self < other.

impl Debug for Limb

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

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<(), Error>

Formats the value using the given formatter.

impl Encoding for Limb

type Repr = [u8; 8]

Byte array representation.

fn from_be_bytes(bytes: <Limb as Encoding>::Repr) -> Limb

Decode from big endian bytes.

fn from_le_bytes(bytes: <Limb as Encoding>::Repr) -> Limb

Decode from little endian bytes.

fn to_be_bytes(&self) -> <Limb as Encoding>::Repr

Encode to big endian bytes.

fn to_le_bytes(&self) -> <Limb as Encoding>::Repr

Encode to little endian bytes.

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

fn from(limb: Limb) -> Uint<LIMBS>

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

Available on 64-bit only.

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

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

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

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

Formats the value using the given formatter.

impl Not for Limb

type Output = Limb

The resulting type after applying the ! operator.

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

Performs the unary ! operation.

impl Ord for Limb

fn cmp(&self, other: &Limb) -> 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: &Limb) -> 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: &Limb) -> 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 random(rng: &mut impl CryptoRngCore) -> Limb

Generate a cryptographically secure random value.

impl RandomMod for Limb

fn random_mod(rng: &mut impl CryptoRngCore, modulus: &NonZero<Limb>) -> Limb

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

impl Shl<usize> for Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> <Limb as Shl<usize>>::Output

Performs the << operation.

impl Shl for Limb

type Output = Limb

The resulting type after applying the << operator.

fn shl(self, rhs: Limb) -> <Limb as Shl>::Output

Performs the << operation.

impl ShlAssign<usize> for Limb

fn shl_assign(&mut self, other: usize)

Performs the <<= operation.

impl ShlAssign for Limb

fn shl_assign(&mut self, other: Limb)

Performs the <<= operation.

impl Shr<usize> for Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> <Limb as Shr<usize>>::Output

Performs the >> operation.

impl Shr for Limb

type Output = Limb

The resulting type after applying the >> operator.

fn shr(self, rhs: Limb) -> <Limb as Shr>::Output

Performs the >> operation.

impl ShrAssign<usize> for Limb

fn shr_assign(&mut self, other: usize)

Performs the >>= operation.

impl ShrAssign for Limb

fn shr_assign(&mut self, other: Limb)

Performs the >>= operation.

impl UpperHex for Limb

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

Formats the value using the given formatter.

impl Zero for Limb

const ZERO: Limb = Self::ZERO

The value 0.

fn is_zero(&self) -> Choice

Determine if this value is equal to zero.

impl Copy for Limb

impl DefaultIsZeroes for Limb

Available on crate feature zeroize only.

impl Eq for Limb