Type Alias U256

pub type U256 = UInt<{ _ }>;

256-bit unsigned big integer.

Aliased Type

struct U256 { /* private fields */ }

Implementations

impl U256

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl U256

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn concat(&self, rhs: &Self) -> UInt<{ _ }>

Concatenate the two values, with self as most significant and rhs as the least significant.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl UInt<{nlimbs!($bits)}>

pub const fn split(&self) -> (UInt<{ _ }>, UInt<{ _ }>)

Split this number in half, returning its high and low components respectively.

impl<const LIMBS: usize> UInt<LIMBS>

pub const ZERO: Self

The value 0.

pub const ONE: Self

The value 1.

pub const LIMBS: usize = LIMBS

The number of limbs used on this platform.

pub const MAX: Self

Maximum value this UInt can express.

pub const fn new(limbs: [Limb; LIMBS]) -> Self

Const-friendly UInt constructor.

pub const fn from_words(arr: [Word; LIMBS]) -> Self

Create a UInt from an array of Words (i.e. word-sized unsigned integers).

pub const fn to_words(self) -> [Word; LIMBS]

Create an array of Words (i.e. word-sized unsigned integers) from a UInt.

pub const fn as_words(&self) -> &[Word; LIMBS]

Borrow the inner limbs as an array of Words.

pub fn as_words_mut(&mut self) -> &mut [Word; LIMBS]

Borrow the inner limbs as a mutable array of Words.

pub const fn as_uint_array(&self) -> &[Word; LIMBS]

👎Deprecated since 0.4.8: please use as_words instead

Deprecated: borrow the inner limbs as an array of Words.

pub const fn from_uint_array(words: [Word; LIMBS]) -> Self

👎Deprecated since 0.4.8: please use from_words instead

Deprecated: create a UInt from an array of Words.

pub const fn to_uint_array(self) -> [Word; LIMBS]

👎Deprecated since 0.4.8: please use to_words instead

Deprecated: create an array of Words from a UInt.

pub const fn limbs(&self) -> &[Limb; LIMBS]

Borrow the limbs of this UInt.

pub fn limbs_mut(&mut self) -> &mut [Limb; LIMBS]

Borrow the limbs of this UInt mutably.

pub const fn into_limbs(self) -> [Limb; LIMBS]

Convert this UInt into its inner limbs.

impl<const LIMBS: usize> UInt<LIMBS>

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

Computes a + b + carry, returning the result along with the new carry.

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

Perform saturating addition, returning MAX on overflow.

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

Perform wrapping addition, discarding overflow.

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn add_mod(&self, rhs: &UInt<LIMBS>, p: &UInt<LIMBS>) -> UInt<LIMBS>

Computes self + rhs mod p in constant time.

Assumes self + rhs as unbounded integer is < 2p.

pub const fn add_mod_special(&self, rhs: &Self, c: Limb) -> Self

Computes self + rhs mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

Assumes self + rhs as unbounded integer is < 2p.

impl<const LIMBS: usize> UInt<LIMBS>

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

Computes bitwise a & b.

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

Perform wrapping bitwise AND.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

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

Perform checked bitwise AND, returning a CtOption which is_some always

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn not(&self) -> Self

Computes bitwise !a.

impl<const LIMBS: usize> UInt<LIMBS>

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

Computes bitwise a & b.

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

Perform wrapping bitwise OR.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

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

Perform checked bitwise OR, returning a CtOption which is_some always

impl<const LIMBS: usize> UInt<LIMBS>

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

Computes bitwise a ^ b.

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

Perform wrapping bitwise `XOR``.

There’s no way wrapping could ever happen. This function exists so that all operations are accounted for in the wrapping operations

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

Perform checked bitwise XOR, returning a CtOption which is_some always

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn bit_vartime(self, index: usize) -> Word

Get the value of the bit at position index, as a 0- or 1-valued Word. Returns 0 for indices out of range.

pub const fn bits(self) -> usize

👎Deprecated: please use bits_vartime instead

Calculate the number of bits needed to represent this number.

pub const fn bits_vartime(self) -> usize

Calculate the number of bits needed to represent this number.

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn reduce2k(&self, k: usize) -> Self

Computes self % 2^k. Faster than reduce since its a power of 2. Limited to 2^16-1 since UInt doesn’t support higher.

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

Computes self / rhs, returns the quotient, remainder if rhs != 0

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

Computes self % rhs, returns the remainder if rhs != 0

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

Wrapped division is just normal division i.e. self / rhs There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

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

Perform checked division, returning a CtOption which is_some only if the rhs != 0

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

Wrapped (modular) remainder calculation is just self % rhs. There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

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

Perform checked reduction, returning a CtOption which is_some only if the rhs != 0

impl<const LIMBS: usize> UInt<LIMBS>

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

Create a new UInt from the provided big endian bytes.

pub const fn from_be_hex(hex: &str) -> Self

Create a new UInt from the provided big endian hex string.

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

Create a new UInt from the provided little endian bytes.

pub const fn from_le_hex(hex: &str) -> Self

Create a new UInt from the provided little endian hex string.

impl<const LIMBS: usize> UInt<LIMBS>

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

Create a UInt from a u8 (const-friendly)

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

Create a UInt from a u16 (const-friendly)

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

Create a UInt from a u32 (const-friendly)

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

Create a UInt from a u64 (const-friendly)

pub const fn from_u128(n: u128) -> Self

Create a UInt from a u128 (const-friendly)

pub const fn from_word(n: Word) -> Self

Create a UInt from a Word (const-friendly)

pub const fn from_wide_word(n: WideWord) -> Self

Create a UInt from a WideWord (const-friendly)

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn inv_mod2k(&self, k: usize) -> Self

Computes 1/self mod 2^k as specified in Algorithm 4 from A Secure Algorithm for Inversion Modulo 2k by Sadiel de la Fe and Carles Ferrer. See https://www.mdpi.com/2410-387X/2/3/23.

Conditions: self < 2^k and self must be odd

impl<const LIMBS: usize> UInt<LIMBS>

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

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

Returns a tuple containing the (lo, hi) components of the product.

Ordering note

Releases of crypto-bigint prior to v0.3 used (hi, lo) ordering instead. This has been changed for better consistency with the rest of the APIs in this crate.

For more info see: https://github.com/RustCrypto/crypto-bigint/issues/4

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

Perform saturating multiplication, returning MAX on overflow.

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

Perform wrapping multiplication, discarding overflow.

pub fn square(&self) -> <Self as Concat>::Output

where Self: Concat,

Square self, returning a “wide” result.

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn mul_mod_special(&self, rhs: &Self, c: Limb) -> Self

Computes self * rhs mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb. For the modulus reduction, this function implements Algorithm 14.47 from the “Handbook of Applied Cryptography”, by A. Menezes, P. van Oorschot, and S. Vanstone, CRC Press, 1996.

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn neg_mod(&self, p: &Self) -> Self

Computes -a mod p in constant time. Assumes self is in [0, p).

pub const fn neg_mod_special(&self, c: Limb) -> Self

Computes -a mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn resize<const T: usize>(&self) -> UInt<T>

Construct a UInt<T> from the unsigned integer value, truncating the upper bits if the value is too large to be represented.

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn shl_vartime(&self, n: usize) -> Self

Computes self << shift.

NOTE: this operation is variable time with respect to n ONLY.

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

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn shr_vartime(&self, shift: usize) -> Self

Computes self >> n.

NOTE: this operation is variable time with respect to n ONLY.

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

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn sqrt(&self) -> Self

Computes √(self) Uses Brent & Zimmermann, Modern Computer Arithmetic, v0.5.9, Algorithm 1.13

Callers can check if self is a square by squaring the result

pub const fn wrapping_sqrt(&self) -> Self

Wrapped sqrt is just normal √(self) There’s no way wrapping could ever happen. This function exists, so that all operations are accounted for in the wrapping operations.

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

Perform checked sqrt, returning a CtOption which is_some only if the √(self)² == self

impl<const LIMBS: usize> UInt<LIMBS>

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

Computes a - (b + borrow), returning the result along with the new borrow.

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

Perform saturating subtraction, returning ZERO on underflow.

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

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

impl<const LIMBS: usize> UInt<LIMBS>

pub const fn sub_mod(&self, rhs: &UInt<LIMBS>, p: &UInt<LIMBS>) -> UInt<LIMBS>

Computes self - rhs mod p in constant time.

Assumes self - rhs as unbounded signed integer is in [-p, p).

pub const fn sub_mod_special(&self, rhs: &Self, c: Limb) -> Self

Computes self - rhs mod p in constant time for the special modulus p = MAX+1-c where c is small enough to fit in a single Limb.

Assumes self - rhs as unbounded signed integer is in [-p, p).

Trait Implementations

impl ArrayEncoding for U256

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>

Size of a byte array which encodes a big integer.

fn from_be_byte_array(bytes: ByteArray<Self>) -> Self

Deserialize from a big-endian byte array.

fn from_le_byte_array(bytes: ByteArray<Self>) -> Self

Deserialize from a little-endian byte array.

fn to_be_byte_array(&self) -> ByteArray<Self>

Serialize to a big-endian byte array.

fn to_le_byte_array(&self) -> ByteArray<Self>

Serialize to a little-endian byte array.

impl Concat for U256

type Output = UInt<{nlimbs!($bits) * 2}>

Concatenated output: twice the width of Self.

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

Concatenate the two values, with self as most significant and rhs as the least significant.

impl Encoding for U256

const BIT_SIZE: usize = 256usize

Size of this integer in bits.

const BYTE_SIZE: usize = 32usize

Size of this integer in bytes.

type Repr = [u8; 32]

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 to_be_bytes(&self) -> Self::Repr

Encode to big endian bytes.

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

Encode to little endian bytes.

impl Split for U256

type Output = UInt<{nlimbs!($bits) / 2}>

Split output: high/low components of the value.

fn split(&self) -> (Self::Output, Self::Output)

Split this number in half, returning its high and low components respectively.

impl<const LIMBS: usize> AddMod for UInt<LIMBS>

type Output = UInt<LIMBS>

Output type.

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

Compute self + rhs mod p.

impl<const LIMBS: usize> AsMut<[Limb]> for UInt<LIMBS>

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

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

impl<const LIMBS: usize> AsMut<[u64; LIMBS]> for UInt<LIMBS>

fn as_mut(&mut self) -> &mut [Word; LIMBS]

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

impl<const LIMBS: usize> AsRef<[Limb]> for UInt<LIMBS>

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

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

impl<const LIMBS: usize> AsRef<[u64; LIMBS]> for UInt<LIMBS>

fn as_ref(&self) -> &[Word; LIMBS]

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

impl<const LIMBS: usize> BitAnd<&UInt<LIMBS>> for UInt<LIMBS>

type Output = UInt<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: &UInt<LIMBS>) -> UInt<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAnd for UInt<LIMBS>

type Output = UInt<LIMBS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> UInt<LIMBS>

Performs the & operation.

impl<const LIMBS: usize> BitAndAssign<&UInt<LIMBS>> for UInt<LIMBS>

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

Performs the &= operation.

impl<const LIMBS: usize> BitAndAssign for UInt<LIMBS>

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl<const LIMBS: usize> BitOr<&UInt<LIMBS>> for UInt<LIMBS>

type Output = UInt<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: &UInt<LIMBS>) -> UInt<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOr for UInt<LIMBS>

type Output = UInt<LIMBS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> UInt<LIMBS>

Performs the | operation.

impl<const LIMBS: usize> BitOrAssign<&UInt<LIMBS>> for UInt<LIMBS>

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

Performs the |= operation.

impl<const LIMBS: usize> BitOrAssign for UInt<LIMBS>

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl<const LIMBS: usize> BitXor<&UInt<LIMBS>> for UInt<LIMBS>

type Output = UInt<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &UInt<LIMBS>) -> UInt<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXor for UInt<LIMBS>

type Output = UInt<LIMBS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> UInt<LIMBS>

Performs the ^ operation.

impl<const LIMBS: usize> BitXorAssign<&UInt<LIMBS>> for UInt<LIMBS>

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

Performs the ^= operation.

impl<const LIMBS: usize> BitXorAssign for UInt<LIMBS>

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl<const LIMBS: usize> CheckedAdd<&UInt<LIMBS>> for UInt<LIMBS>

type Output = UInt<LIMBS>

Output type.

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

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

impl<const LIMBS: usize> CheckedMul<&UInt<LIMBS>> for UInt<LIMBS>

type Output = UInt<LIMBS>

Output type.

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<const LIMBS: usize> CheckedSub<&UInt<LIMBS>> for UInt<LIMBS>

type Output = UInt<LIMBS>

Output type.

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<const LIMBS: usize> Clone for UInt<LIMBS>

fn clone(&self) -> UInt<LIMBS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const LIMBS: usize> ConditionallySelectable for UInt<LIMBS>

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<const LIMBS: usize> ConstantTimeEq for UInt<LIMBS>

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<const LIMBS: usize> ConstantTimeGreater for UInt<LIMBS>

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

Determine whether self > other.

impl<const LIMBS: usize> ConstantTimeLess for UInt<LIMBS>

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

Determine whether self < other.

impl<const LIMBS: usize> Debug for UInt<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> Default for UInt<LIMBS>

fn default() -> Self

Returns the “default value” for a type.

impl<const LIMBS: usize> Display for UInt<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> Div<&NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

type Output = UInt<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: &NonZero<UInt<LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize> Div<NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

type Output = UInt<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: NonZero<UInt<LIMBS>>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize> DivAssign<&NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

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

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

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

Performs the /= operation.

impl<const LIMBS: usize> From<[Limb; LIMBS]> for UInt<LIMBS>

fn from(limbs: [Limb; LIMBS]) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<[u64; LIMBS]> for UInt<LIMBS>

fn from(arr: [Word; LIMBS]) -> Self

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U1024, U1024)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U128, U128)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U1536, U1536)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U1792, U1792)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U192, U192)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U2048, U2048)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U256, U256)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U3072, U3072)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U384, U384)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U4096, U4096)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U448, U448)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U512, U512)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U64, U64)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U768, U768)) -> UInt<{ _ }>

Converts to this type from the input type.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ _ }>

fn from(nums: (U896, U896)) -> UInt<{ _ }>

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<const LIMBS: usize> From<u128> for UInt<LIMBS>

fn from(n: u128) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<u16> for UInt<LIMBS>

fn from(n: u16) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<u32> for UInt<LIMBS>

fn from(n: u32) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<u64> for UInt<LIMBS>

fn from(n: u64) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> From<u8> for UInt<LIMBS>

fn from(n: u8) -> Self

Converts to this type from the input type.

impl<const LIMBS: usize> Hash for UInt<LIMBS>

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<const LIMBS: usize> Integer for UInt<LIMBS>

const ONE: Self = Self::ONE

The value 1.

const MAX: Self = Self::MAX

Maximum value this integer can express.

fn is_odd(&self) -> Choice

Is this integer value an odd number?

fn is_even(&self) -> Choice

Is this integer value an even number?

impl<const LIMBS: usize> LowerHex for UInt<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> NegMod for UInt<LIMBS>

type Output = UInt<LIMBS>

Output type.

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

Compute -self mod p.

impl<const LIMBS: usize> Not for UInt<LIMBS>

type Output = UInt<LIMBS>

The resulting type after applying the ! operator.

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

Performs the unary ! operation.

impl<const LIMBS: usize> Ord for UInt<LIMBS>

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<const LIMBS: usize> PartialEq for UInt<LIMBS>

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<const LIMBS: usize> PartialOrd for UInt<LIMBS>

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<const LIMBS: usize> Random for UInt<LIMBS>

fn random(rng: impl CryptoRng + RngCore) -> Self

Generate a cryptographically secure random UInt.

impl<const LIMBS: usize> RandomMod for UInt<LIMBS>

fn random_mod(rng: impl CryptoRng + RngCore, modulus: &NonZero<Self>) -> Self

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

This function uses rejection sampling, a method which produces an unbiased distribution of in-range values provided the underlying CryptoRng is unbiased, but runs in variable-time.

The variable-time nature of the algorithm should not pose a security issue so long as the underlying random number generator is truly a CryptoRng, where previous outputs are unrelated to subsequent outputs and do not reveal information about the RNG’s internal state.

impl<const LIMBS: usize> Rem<&NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

type Output = UInt<LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: &NonZero<UInt<LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize> Rem<NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

type Output = UInt<LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: NonZero<UInt<LIMBS>>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize> RemAssign<&NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

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

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<NonZero<UInt<LIMBS>>> for UInt<LIMBS>

where UInt<LIMBS>: Integer,

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

Performs the %= operation.

impl<const LIMBS: usize> Shl<usize> for UInt<LIMBS>

fn shl(self, rhs: usize) -> UInt<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

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

type Output = UInt<LIMBS>

The resulting type after applying the << operator.

impl<const LIMBS: usize> ShlAssign<usize> for UInt<LIMBS>

fn shl_assign(&mut self, rhs: usize)

NOTE: this operation is variable time with respect to rhs ONLY.

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

impl<const LIMBS: usize> Shr<usize> for UInt<LIMBS>

fn shr(self, rhs: usize) -> UInt<LIMBS>

NOTE: this operation is variable time with respect to rhs ONLY.

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

type Output = UInt<LIMBS>

The resulting type after applying the >> operator.

impl<const LIMBS: usize> ShrAssign<usize> for UInt<LIMBS>

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl<const LIMBS: usize> SubMod for UInt<LIMBS>

type Output = UInt<LIMBS>

Output type.

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

Compute self - rhs mod p.

impl<const LIMBS: usize> UpperHex for UInt<LIMBS>

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

Formats the value using the given formatter.

impl<const LIMBS: usize> Zero for UInt<LIMBS>

const ZERO: Self = Self::ZERO

The value 0.

fn is_zero(&self) -> Choice

Determine if this value is equal to zero.

impl<const LIMBS: usize> Copy for UInt<LIMBS>

impl<const LIMBS: usize> DefaultIsZeroes for UInt<LIMBS>

impl<const LIMBS: usize> Eq for UInt<LIMBS>