Type Alias U3072

pub type U3072 = Uint<{ _ }>;

3072-bit unsigned big integer.

Aliased Type

struct U3072 { /* private fields */ }

Implementations

impl U3072

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

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U1024

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U128

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U1280

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U1536

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U16384

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U1792

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U2048

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U256

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U3072

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U3584

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U384

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U4096

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U4224

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U4352

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U512

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U6144

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U640

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U768

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U8192

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

impl Uint<{ _ }>

pub const fn concat(&self, lo: &Uint<{ _ }>) -> U896

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 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 MAX: Self

Maximum value this Uint can express.

pub const BITS: usize

Total size of the represented integer in bits.

pub const BYTES: usize

Total size of the represented integer in bytes.

pub const LIMBS: usize = LIMBS

The number of limbs used on this platform.

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

Borrow the limbs of this Uint.

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

Borrow the limbs of this Uint mutably.

pub const fn to_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.

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 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) -> bool

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

Remarks

This operation is variable time with respect to index only.

pub const fn bits_vartime(&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 leading_zeros_vartime(&self) -> usize

Calculate the number of leading zeros in the binary representation of this number, variable time in self.

pub const fn trailing_zeros(&self) -> usize

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

pub const fn trailing_zeros_vartime(&self) -> usize

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

pub const fn trailing_ones(&self) -> usize

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

pub const fn trailing_ones_vartime(&self) -> usize

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

pub const fn bits(&self) -> usize

Calculate the number of bits needed to represent this number.

pub const fn bit(&self, index: usize) -> CtChoice

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

impl<const LIMBS: usize> Uint<LIMBS>

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

Returns the Ordering between self and rhs in variable time.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn ct_div_rem_limb_with_reciprocal( &self, reciprocal: &Reciprocal, ) -> (Self, Limb)

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

pub fn div_rem_limb_with_reciprocal( &self, reciprocal: &CtOption<Reciprocal>, ) -> CtOption<(Self, Limb)>

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

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

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

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

Computes self % rhs, returns the remainder and and the truthy value for is_some or the falsy value for is_none.

NOTE: Use only if you need to access const fn. Otherwise use Self::rem. This is variable only with respect to rhs.

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

pub const fn const_rem_wide( lower_upper: (Self, Self), rhs: &Self, ) -> (Self, CtChoice)

Computes self % rhs, returns the remainder and and the truthy value for is_some or the falsy value for is_none.

This is variable only with respect to rhs.

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

pub const fn rem2k(&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: &NonZero<Self>) -> (Self, Self)

Computes self / rhs, returns the quotient, remainder.

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

Computes self % rhs, returns the remainder.

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.

Panics if rhs == 0.

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.

Panics if rhs == 0.

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_vartime(&self, k: usize) -> Self

Computes 1/self mod 2^k. This method is constant-time w.r.t. self but not k.

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

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

Computes 1/self mod 2^k.

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

pub const fn inv_odd_mod_bounded( &self, modulus: &Self, bits: usize, modulus_bits: usize, ) -> (Self, CtChoice)

Computes the multiplicative inverse of self mod modulus, where modulus is odd. In other words self^-1 mod modulus. bits and modulus_bits are the bounds on the bit size of self and modulus, respectively (the inversion speed will be proportional to bits + modulus_bits). The second element of the tuple is the truthy value if an inverse exists, otherwise it is a falsy value.

Note: variable time in bits and modulus_bits.

The algorithm is the same as in GMP 6.2.1’s mpn_sec_invert.

pub const fn inv_odd_mod(&self, modulus: &Self) -> (Self, CtChoice)

Computes the multiplicative inverse of self mod modulus, where modulus is odd. Returns (inverse, CtChoice::TRUE) if an inverse exists, otherwise (undefined, CtChoice::FALSE).

pub const fn inv_mod(&self, modulus: &Self) -> (Self, CtChoice)

Computes the multiplicative inverse of self mod modulus. Returns (inverse, CtChoice::TRUE) if an inverse exists, otherwise (undefined, CtChoice::FALSE).

impl<const LIMBS: usize> Uint<LIMBS>

pub fn mul<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS>, ) -> <Uint<HLIMBS> as ConcatMixed<Self>>::MixedOutput

where Uint<HLIMBS>: ConcatMixed<Self>,

Multiply self by rhs, returning a concatenated “wide” result.

pub const fn mul_wide<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS>, ) -> (Self, Uint<HLIMBS>)

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<const HLIMBS: usize>( &self, rhs: &Uint<HLIMBS>, ) -> Self

Perform saturating multiplication, returning MAX on overflow.

pub const fn wrapping_mul<const H: usize>(&self, rhs: &Uint<H>) -> Self

Perform wrapping multiplication, discarding overflow.

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

where Self: Concat,

Square self, returning a concatenated “wide” result.

pub const fn square_wide(&self) -> (Self, Self)

Square self, returning a “wide” result in two parts as (lo, hi).

impl<const LIMBS: usize> Uint<LIMBS>

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

Computes self * rhs mod p 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 wrapping_neg(&self) -> Self

Perform wrapping negation.

impl<const LIMBS: usize> Uint<LIMBS>

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

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

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

Computes -a mod p 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.

pub const fn shl_vartime_wide( lower_upper: (Self, Self), n: usize, ) -> (Self, Self)

Computes a left shift on a wide input as (lo, hi).

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.

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

Computes self << n. Returns zero if n >= Self::BITS.

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.

pub const fn shr_vartime_wide( lower_upper: (Self, Self), n: usize, ) -> (Self, Self)

Computes a right shift on a wide input as (lo, hi).

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.

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

Computes self << n. Returns zero if n >= Self::BITS.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn sqrt(&self) -> Self

👎Deprecated since 0.5.3: This functionality will be moved to sqrt_vartime in a future release.

See Self::sqrt_vartime.

pub const fn sqrt_vartime(&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

👎Deprecated since 0.5.3: This functionality will be moved to wrapping_sqrt_vartime in a future release.

See Self::wrapping_sqrt_vartime.

pub const fn wrapping_sqrt_vartime(&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>

👎Deprecated since 0.5.3: This functionality will be moved to checked_sqrt_vartime in a future release.

See Self::checked_sqrt_vartime.

pub fn checked_sqrt_vartime(&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.

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 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 U3072

type ByteSize = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, 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 Encoding for U3072

type Repr = [u8; 384]

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 U3072

type Output = Uint<{ <$name>::LIMBS / 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 SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3072

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, 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> Bounded for Uint<LIMBS>

const BITS: usize = Self::BITS

Size of this integer in bits.

const BYTES: usize = Self::BYTES

Size of this integer in bytes.

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, const HLIMBS: usize> CheckedMul<&Uint<HLIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn checked_mul(&self, rhs: &Uint<HLIMBS>) -> 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 ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ <$name>::LIMBS / 2 }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{nlimbs!($bits)}>

Concatenated output: combination of Lo and Self.

fn concat_mixed(&self, lo: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as most significant and lo 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> 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<Limb>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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<Limb>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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<Limb>> for Uint<LIMBS>

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<const LIMBS: usize> DivAssign<NonZero<Limb>> for Uint<LIMBS>

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

Performs the /= operation.

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

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

Performs the /= operation.

impl<const L: usize, const H: usize, const LIMBS: usize> From<&(Uint<L>, Uint<H>)> for Uint<LIMBS>

where Uint<H>: ConcatMixed<Uint<L>, MixedOutput = Uint<LIMBS>>,

fn from(nums: &(Uint<L>, Uint<H>)) -> Uint<LIMBS>

Converts to this type from the input type.

impl<const LIMBS: usize, const LIMBS2: usize> From<&Uint<LIMBS>> for Uint<LIMBS2>

fn from(num: &Uint<LIMBS>) -> Uint<LIMBS2>

Converts to this type from the input type.

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<const L: usize, const H: usize, const LIMBS: usize> From<(Uint<L>, Uint<H>)> for Uint<LIMBS>

where Uint<H>: ConcatMixed<Uint<L>, MixedOutput = Uint<LIMBS>>,

fn from(nums: (Uint<L>, Uint<H>)) -> Uint<LIMBS>

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.

const BITS: usize = Self::BITS

Total size of the represented integer in bits.

const BYTES: usize = Self::BYTES

Total size of the represented integer in bytes.

const LIMBS: usize = Self::LIMBS

The number of limbs used on this platform.

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, const HLIMBS: usize> Mul<&Uint<HLIMBS>> for Uint<LIMBS>

where Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

type Output = <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutput

The resulting type after applying the * operator.

fn mul(self, other: &Uint<HLIMBS>) -> Self::Output

Performs the * operation.

impl<const LIMBS: usize, const HLIMBS: usize> Mul<Uint<HLIMBS>> for Uint<LIMBS>

where Uint<HLIMBS>: ConcatMixed<Uint<LIMBS>>,

type Output = <Uint<HLIMBS> as ConcatMixed<Uint<LIMBS>>>::MixedOutput

The resulting type after applying the * operator.

fn mul(self, other: Uint<HLIMBS>) -> Self::Output

Performs the * operation.

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: &mut impl CryptoRngCore) -> Self

Generate a cryptographically secure random Uint.

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

fn random_mod(rng: &mut impl CryptoRngCore, 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 CSRNG 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 CSRNG, 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<Limb>> for Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

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

Performs the % operation.

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

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<Limb>> for Uint<LIMBS>

type Output = Limb

The resulting type after applying the % operator.

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

Performs the % operation.

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

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<Limb>> for Uint<LIMBS>

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

Performs the %= operation.

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

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

Performs the %= operation.

impl<const LIMBS: usize> RemAssign<NonZero<Limb>> for Uint<LIMBS>

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

Performs the %= operation.

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

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 SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U128

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1280

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1536

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U16384

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1792

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2048

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U256

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3584

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U384

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4096

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4224

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4352

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U512

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6144

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U8192

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U1024

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U192

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U192

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U256

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U256

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U320

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U320

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U320

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U320

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U384

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U384

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U384

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U384

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U448

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U448

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U448

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U448

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U448

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U448

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U512

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U512

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U512

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U512

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U512

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U512

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U576

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U640

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U704

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U768

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U832

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U896

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

impl SplitMixed<Uint<{ U64::LIMBS * $size }>, Uint<{ <$name>::LIMBS - U64::LIMBS * $size }>> for U960

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its high and low components respectively.

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>