Struct crypto_bigint::UInt

pub struct UInt<const LIMBS: usize> { /* fields omitted */ }

Big unsigned integer.

Generic over the given number of LIMBS

Encoding support

This type supports many different types of encodings, either via the Encoding trait or various const fn decoding and encoding functions that can be used with UInt constants.

Optional crate features for encoding (off-by-default):

• generic-array: enables ArrayEncoding trait which can be used to UInt as GenericArray<u8, N> and a ArrayDecoding trait which can be used to GenericArray<u8, N> as UInt.
• rlp: support for Recursive Length Prefix (RLP) encoding.

Implementations

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 and rhs are < p.

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 bits(self) -> usize

Calculate the number of bits needed to represent this number.

impl<const LIMBS: usize> UInt<LIMBS>

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_uint_array(arr: [LimbUInt; LIMBS]) -> Self

Create a UInt from an array of the LimbUInt unsigned integer type.

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

Create an array of LimbUInt unsigned integers from a UInt.

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 neg_mod(&self, p: &Self) -> Self

Computes -a mod p in constant time.

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 and rhs are < p.

impl<const LIMBS: usize> UInt<LIMBS>

pub const ZERO: Self

The value 0.

pub const ONE: Self

The value 1.

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 limbs(&self) -> &[Limb; LIMBS]

Borrow the limbs of this UInt.

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

Convert this UInt into its inner limbs.

Trait Implementations

impl AddMod<UInt<10_usize>> for UInt<10>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<11_usize>> for UInt<11>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<12_usize>> for UInt<12>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<1_usize>> for UInt<1>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<2_usize>> for UInt<2>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<3_usize>> for UInt<3>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<4_usize>> for UInt<4>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<5_usize>> for UInt<5>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<6_usize>> for UInt<6>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<7_usize>> for UInt<7>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<8_usize>> for UInt<8>

type Output = Self

Output type.

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

Compute self + rhs mod p.

impl AddMod<UInt<9_usize>> for UInt<9>

type Output = Self

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]

Performs the conversion.

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

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

Performs the conversion.

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<&'_ 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<UInt<LIMBS>> for UInt<LIMBS>

type Output = Self

The resulting type after applying the & operator.

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

Performs the & operation.

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> BitAndAssign<&'_ UInt<LIMBS>> for UInt<LIMBS>

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

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> 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<&'_ 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<UInt<LIMBS>> for UInt<LIMBS>

type Output = Self

The resulting type after applying the | operator.

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

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> BitOrAssign<&'_ UInt<LIMBS>> for UInt<LIMBS>

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

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> 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<&'_ 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<UInt<LIMBS>> for UInt<LIMBS>

type Output = Self

The resulting type after applying the ^ operator.

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

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> BitXorAssign<&'_ UInt<LIMBS>> for UInt<LIMBS>

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

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> CheckedAdd<&'_ UInt<LIMBS>> for UInt<LIMBS>

type Output = Self

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 = Self

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 = Self

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 Concat<UInt<{nlimbs!($bits)}>> for U64

type Output = UInt<{ 64 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 128 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 1536 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 1792 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 2048 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 3072 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 4096 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 192 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 256 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 384 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 448 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 512 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 768 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 896 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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

type Output = UInt<{ 1024 / crate::Limb::BIT_SIZE * 2 }>

Concatenated output: twice the width of Self.

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

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

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.

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> Decodable for UInt<LIMBS> where
    Self: Encoding,
    <Self as Encoding>::Repr: Default, 

This is supported on crate feature rlp only.

fn decode(rlp: &Rlp<'_>) -> Result<Self, DecoderError>

Decode a value from RLP bytes

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> 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> Encodable for UInt<LIMBS> where
    Self: Encoding, 

This is supported on crate feature rlp only.

fn rlp_append(&self, stream: &mut RlpStream)

Append a value to the stream

fn rlp_bytes(&self) -> BytesMut

Get rlp-encoded bytes for this instance

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

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

Performs the conversion.

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

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

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 64 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U64, U64)) -> UInt<{ 64 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 128 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U128, U128)) -> UInt<{ 128 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 1536 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U1536, U1536)) -> UInt<{ 1536 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 1792 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U1792, U1792)) -> UInt<{ 1792 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 2048 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U2048, U2048)) -> UInt<{ 2048 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 3072 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U3072, U3072)) -> UInt<{ 3072 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 4096 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U4096, U4096)) -> UInt<{ 4096 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 192 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U192, U192)) -> UInt<{ 192 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 256 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U256, U256)) -> UInt<{ 256 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 384 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U384, U384)) -> UInt<{ 384 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 448 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U448, U448)) -> UInt<{ 448 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 512 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U512, U512)) -> UInt<{ 512 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 768 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U768, U768)) -> UInt<{ 768 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 896 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U896, U896)) -> UInt<{ 896 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

impl From<(UInt<{nlimbs!($bits)}>, UInt<{nlimbs!($bits)}>)> for UInt<{ 1024 / crate::Limb::BIT_SIZE * 2 }>

fn from(nums: (U1024, U1024)) -> UInt<{ 1024 / crate::Limb::BIT_SIZE * 2 }>

Performs the conversion.

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

fn from(limb: Limb) -> Self

Performs the conversion.

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

fn from(n: UInt<LIMBS>) -> [LimbUInt; LIMBS]

Performs the conversion.

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

fn from(n: UInt<LIMBS>) -> [Limb; LIMBS]

Performs the conversion.

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

This is supported on 64-bit only.

fn from(n: U64) -> u64

Performs the conversion.

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

fn from(n: U128) -> u128

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 1024 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 1024 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U1024
) -> (UInt<{ 1024 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 1024 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 1536 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 1536 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U1536
) -> (UInt<{ 1536 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 1536 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 1792 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 1792 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U1792
) -> (UInt<{ 1792 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 1792 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 2048 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 2048 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U2048
) -> (UInt<{ 2048 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 2048 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 3072 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 3072 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U3072
) -> (UInt<{ 3072 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 3072 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 3584 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 3584 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U3584
) -> (UInt<{ 3584 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 3584 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 4096 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 4096 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U4096
) -> (UInt<{ 4096 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 4096 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 6144 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 6144 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U6144
) -> (UInt<{ 6144 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 6144 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 8192 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 8192 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U8192
) -> (UInt<{ 8192 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 8192 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 128 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 128 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U128
) -> (UInt<{ 128 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 128 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 192 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 192 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U192
) -> (UInt<{ 192 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 192 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 256 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 256 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U256
) -> (UInt<{ 256 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 256 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 384 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 384 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U384
) -> (UInt<{ 384 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 384 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 448 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 448 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U448
) -> (UInt<{ 448 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 448 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 512 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 512 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U512
) -> (UInt<{ 512 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 512 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 768 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 768 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U768
) -> (UInt<{ 768 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 768 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

impl From<UInt<{nlimbs!($bits)}>> for (UInt<{ 896 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 896 / crate::Limb::BIT_SIZE / 2 }>)

fn from(
    num: U896
) -> (UInt<{ 896 / crate::Limb::BIT_SIZE / 2 }>, UInt<{ 896 / crate::Limb::BIT_SIZE / 2 }>)

Performs the conversion.

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

fn from(n: u128) -> Self

Performs the conversion.

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

fn from(n: u16) -> Self

Performs the conversion.

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

fn from(n: u32) -> Self

Performs the conversion.

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

fn from(n: u64) -> Self

Performs the conversion.

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

fn from(n: u8) -> Self

Performs the conversion.

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, 

Feeds a slice of this type into the given Hasher.

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

const ONE: Self

The value 1.

const MAX: Self

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 NegMod for UInt<1>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<2>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<11>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<12>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<3>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<4>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<5>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<6>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<7>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<8>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<9>

type Output = Self

Output type.

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

Compute -self mod p.

impl NegMod for UInt<10>

type Output = Self

Output type.

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

Compute -self mod p.

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

type Output = Self

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

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

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

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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

This is supported on crate feature rand_core only.

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

Generate a cryptographically secure random UInt.

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

This is supported on crate feature rand_core only.

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> 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> 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> 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 Split<UInt<{nlimbs!($bits)}>> for U128

type Output = UInt<{ 128 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U192

type Output = UInt<{ 192 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U1792

type Output = UInt<{ 1792 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U2048

type Output = UInt<{ 2048 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U3072

type Output = UInt<{ 3072 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U3584

type Output = UInt<{ 3584 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U4096

type Output = UInt<{ 4096 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U6144

type Output = UInt<{ 6144 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U8192

type Output = UInt<{ 8192 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U256

type Output = UInt<{ 256 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U384

type Output = UInt<{ 384 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U448

type Output = UInt<{ 448 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U512

type Output = UInt<{ 512 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U768

type Output = UInt<{ 768 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U896

type Output = UInt<{ 896 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U1024

type Output = UInt<{ 1024 / crate::Limb::BIT_SIZE / 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 Split<UInt<{nlimbs!($bits)}>> for U1536

type Output = UInt<{ 1536 / crate::Limb::BIT_SIZE / 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 SubMod<UInt<10_usize>> for UInt<10>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<11_usize>> for UInt<11>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<12_usize>> for UInt<12>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<1_usize>> for UInt<1>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<2_usize>> for UInt<2>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<3_usize>> for UInt<3>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<4_usize>> for UInt<4>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<5_usize>> for UInt<5>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<6_usize>> for UInt<6>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<7_usize>> for UInt<7>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<8_usize>> for UInt<8>

type Output = Self

Output type.

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

Compute self - rhs mod p.

impl SubMod<UInt<9_usize>> for UInt<9>

type Output = Self

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

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>

This is supported on crate feature zeroize only.

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