Struct Uint

pub struct Uint<const LIMBS: usize> { /* private fields */ }

Stack-allocated big unsigned integer.

Generic over the given number of LIMBS

Encoding support

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

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

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

Implementations

impl<const LIMBS: usize> Uint<LIMBS>

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

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

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

Perform saturating addition, returning MAX on overflow.

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

Perform wrapping addition, discarding overflow.

impl<const LIMBS: usize> Uint<LIMBS>

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

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.

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

Computes self + self mod p.

Assumes self as unbounded integer is < p.

impl<const LIMBS: usize> Uint<LIMBS>

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

Computes bitwise a & b.

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

Perform bitwise AND between self and the given Limb, performing the AND operation on every limb of self.

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(&self, index: u32) -> ConstChoice

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

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

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

Remarks

This operation is variable time with respect to index only.

pub const fn bits(&self) -> u32

Calculate the number of bits needed to represent this number.

pub const fn bits_vartime(&self) -> u32

Calculate the number of bits needed to represent this number in variable-time with respect to self.

pub const fn leading_zeros(&self) -> u32

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

pub const fn leading_zeros_vartime(&self) -> u32

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

pub const fn trailing_zeros(&self) -> u32

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

pub const fn trailing_zeros_vartime(&self) -> u32

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

pub const fn trailing_ones(&self) -> u32

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

pub const fn trailing_ones_vartime(&self) -> u32

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

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 L: usize> Uint<L>

pub const fn concat<const O: usize>(&self, hi: &Self) -> Uint<O>

where Self: Concat<Output = Uint<O>>,

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

pub const fn concat_mixed<const H: usize, const O: usize>( lo: &Uint<L>, hi: &Uint<H>, ) -> Uint<O>

where Self: ConcatMixed<Uint<H>, MixedOutput = Uint<O>>,

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

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn 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 const fn div_rem_limb(&self, rhs: NonZero<Limb>) -> (Self, Limb)

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

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

Computes self % rhs using a pre-made reciprocal.

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

Computes self % rhs.

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

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

This function is constant-time with respect to both self and rhs.

pub const fn div_rem_vartime<const RHS_LIMBS: usize>( &self, rhs: &NonZero<Uint<RHS_LIMBS>>, ) -> (Self, Uint<RHS_LIMBS>)

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

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 rem(&self, rhs: &NonZero<Self>) -> Self

Computes self % rhs, returns the remainder.

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

Computes self % rhs, returns the remainder in variable-time with respect to rhs.

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

pub const fn rem_wide_vartime( lower_upper: (Self, Self), rhs: &NonZero<Self>, ) -> Self

Computes self % rhs, returns the remainder.

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

Usage:

use crypto_bigint::{U448, Limb};

let a = U448::from(10_u64);
let k = 3; // 2^3 = 8
let remainder = a.rem2k_vartime(k);

// As 10 % 8 = 2
assert_eq!(remainder, U448::from(2_u64));

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

Wrapped division is just normal division i.e. self / rhs

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

pub const fn wrapping_div_vartime<const RHS: usize>( &self, rhs: &NonZero<Uint<RHS>>, ) -> Self

Wrapped division is just normal division i.e. self / rhs

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

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

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

Usage:

use crypto_bigint::{U448, NonZero, subtle::{CtOption, Choice}};

let a = U448::from(8_u64);
let result = NonZero::new(U448::from(4_u64))
    .map(|b| a.div_rem(&b))
    .expect("Division by zero");

assert_eq!(result.0, U448::from(2_u64));

// Check division by zero
let zero = U448::from(0_u64);
assert!(bool::from(a.checked_div(&zero).is_none()), "Should be None for division by zero");

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

This function exists, so that all operations are accounted for in the wrapping operations. Panics if rhs == 0.

Usage:

use crypto_bigint::U448;

let a = U448::from(10_u64);
let b = U448::from(3_u64);
let remainder = a.wrapping_rem_vartime(&b);

assert_eq!(remainder, U448::from(1_u64));

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

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

Usage:

use crypto_bigint::{U448, NonZero, subtle::{Choice,CtOption}};

let a = U448::from(10_u64);
let remainder_option = NonZero::new(U448::from(3_u64))
    .map(|b| a.rem(&b));

assert!(bool::from(remainder_option.is_some()));

// Check reduction by zero
let zero = U448::from(0_u64);

assert!(bool::from(a.checked_rem(&zero).is_none()), "Should be None for reduction by zero");

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.

Panics if the hex is malformed or not zero-padded accordingly for the size.

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.

Panics if the hex is malformed or not zero-padded accordingly for the size.

pub fn from_str_radix_vartime( src: &str, radix: u32, ) -> Result<Self, DecodeError>

Create a new Uint from a string slice in a given base.

The string may begin with a + character, and may use underscore characters to separate digits.

If the input value contains non-digit characters or digits outside of the range 0..radix this function will return DecodeError::InvalidDigit. If the size of the decoded integer is larger than this type can represent, this function will return DecodeError::InputSize. Panics if radix is not in the range from 2 to 36.

pub fn to_string_radix_vartime(&self, radix: u32) -> String

Available on crate feature alloc only.

Format a Uint as a string in a given base.

Panics if radix is not in the range from 2 to 36.

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

Available on 32-bit only.

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 SAT_LIMBS: usize, const UNSAT_LIMBS: usize> Uint<SAT_LIMBS>

where Odd<Self>: PrecomputeInverter<Inverter = SafeGcdInverter<SAT_LIMBS, UNSAT_LIMBS>>,

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

Compute the greatest common divisor (GCD) of this number and another.

Runs in a constant number of iterations depending on the maximum highest bit of either self or rhs.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn inv_mod2k_vartime(&self, k: u32) -> ConstCtOption<Self>

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

If the inverse does not exist (k > 0 and self is even), returns ConstChoice::FALSE as the second element of the tuple, otherwise returns ConstChoice::TRUE.

pub const fn inv_mod2k(&self, k: u32) -> ConstCtOption<Self>

Computes 1/self mod 2^k.

If the inverse does not exist (k > 0 and self is even), returns ConstChoice::FALSE as the second element of the tuple, otherwise returns ConstChoice::TRUE.

impl<const LIMBS: usize, const UNSAT_LIMBS: usize> Uint<LIMBS>

where Odd<Self>: PrecomputeInverter<Inverter = SafeGcdInverter<LIMBS, UNSAT_LIMBS>>,

pub const fn inv_odd_mod(&self, modulus: &Odd<Self>) -> ConstCtOption<Self>

Computes the multiplicative inverse of self mod modulus, where modulus is odd.

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

Computes the multiplicative inverse of self mod modulus.

Returns some if an inverse exists, otherwise none.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn widening_mul<const RHS_LIMBS: usize, const WIDE_LIMBS: usize>( &self, rhs: &Uint<RHS_LIMBS>, ) -> Uint<WIDE_LIMBS>

where Self: ConcatMixed<Uint<RHS_LIMBS>, MixedOutput = Uint<WIDE_LIMBS>>,

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

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

Compute “wide” multiplication as a 2-tuple containing the (lo, hi) components of the product, whose sizes correspond to the sizes of the operands.

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

Perform wrapping multiplication, discarding overflow.

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

Perform saturating multiplication, returning MAX on overflow.

impl<const LIMBS: usize> Uint<LIMBS>

Squaring operations

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

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

pub const fn widening_square<const WIDE_LIMBS: usize>(&self) -> Uint<WIDE_LIMBS>

where Self: ConcatMixed<Uint<LIMBS>, MixedOutput = Uint<WIDE_LIMBS>>,

Square self, returning a concatenated “wide” result.

pub const fn checked_square(&self) -> ConstCtOption<Uint<LIMBS>>

Square self, checking that the result fits in the original Uint size.

pub const fn wrapping_square(&self) -> Uint<LIMBS>

Perform wrapping square, discarding overflow.

pub const fn saturating_square(&self) -> Self

Perform saturating squaring, returning MAX on overflow.

impl<const LIMBS: usize, const WIDE_LIMBS: usize> Uint<LIMBS>

where Self: Concat<Output = Uint<WIDE_LIMBS>>,

pub const fn square(&self) -> Uint<WIDE_LIMBS>

Square self, returning a concatenated “wide” result.

impl<const LIMBS: usize> Uint<LIMBS>

pub fn mul_mod<const WIDE_LIMBS: usize>( &self, rhs: &Uint<LIMBS>, p: &NonZero<Uint<LIMBS>>, ) -> Uint<LIMBS>

where Uint<LIMBS>: Concat<Output = Uint<WIDE_LIMBS>>, Uint<WIDE_LIMBS>: Split<Output = Uint<LIMBS>>,

Computes self * rhs mod p for odd p.

Panics if p is even. (TODO: support even p)

pub fn mul_mod_vartime( &self, rhs: &Uint<LIMBS>, p: &NonZero<Uint<LIMBS>>, ) -> Uint<LIMBS>

Computes self * rhs mod p for odd p in variable time with respect to p.

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.

pub const fn carrying_neg(&self) -> (Self, ConstChoice)

Perform negation: map self to (self ^ 1111...1111) + 0000...0001. Additionally return whether the carry flag is set on the addition.

Note: the carry is set if and only if self == Self::ZERO.

pub const fn wrapping_neg_if(&self, negate: ConstChoice) -> Self

Perform wrapping negation, if negate is truthy. Otherwise, return self.

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(&self, shift: u32) -> Self

Computes self << shift.

Panics if shift >= Self::BITS.

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

Computes self << shift in variable time.

Panics if shift >= Self::BITS.

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

Computes self << shift.

Returns None if shift >= Self::BITS.

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

Computes self << shift.

Returns None if shift >= Self::BITS.

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

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

pub const fn overflowing_shl_vartime_wide( lower_upper: (Self, Self), shift: u32, ) -> ConstCtOption<(Self, Self)>

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

Returns None if shift >= Self::BITS.

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

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

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

Computes self << shift in a panic-free manner, returning zero if the shift exceeds the precision.

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

Computes self << shift in variable-time in a panic-free manner, returning zero if the shift exceeds the precision.

impl<const LIMBS: usize> Uint<LIMBS>

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

Computes self >> shift.

Panics if shift >= Self::BITS.

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

Computes self >> shift in variable time.

Panics if shift >= Self::BITS.

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

Computes self >> shift.

Returns None if shift >= Self::BITS.

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

Computes self >> shift.

Returns None if shift >= Self::BITS.

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

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

pub const fn overflowing_shr_vartime_wide( lower_upper: (Self, Self), shift: u32, ) -> ConstCtOption<(Self, Self)>

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

Returns None if shift >= Self::BITS.

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

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

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

Computes self >> shift in a panic-free manner, returning zero if the shift exceeds the precision.

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

Computes self >> shift in variable-time in a panic-free manner, returning zero if the shift exceeds the precision.

impl<const I: usize> Uint<I>

pub const fn split<const O: usize>(&self) -> (Uint<O>, Uint<O>)

where Self: Split<Output = Uint<O>>,

Split this number in half into low and high components.

pub const fn split_mixed<const L: usize, const H: usize>( &self, ) -> (Uint<L>, Uint<H>)

where Self: SplitMixed<Uint<L>, Uint<H>>,

Split this number into low and high components respectively.

impl<const LIMBS: usize> Uint<LIMBS>

pub const fn sqrt(&self) -> Self

Computes √(self) in constant time.

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

pub const fn sqrt_vartime(&self) -> Self

Computes √(self)

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

pub const fn wrapping_sqrt(&self) -> Self

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

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

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

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

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

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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

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

Available on crate feature extra-sizes only.

Serialize as big endian bytes.

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

Available on crate feature extra-sizes only.

Serialize as little endian bytes.

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: u32

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 const 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.

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

Convert to a NonZero<Uint<LIMBS>>.

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

pub const fn to_odd(self) -> ConstCtOption<Odd<Self>>

Convert to a Odd<Uint<LIMBS>>.

Returns some if the original value is odd, and false otherwise.

pub const fn as_int(&self) -> Int<LIMBS>

Interpret the data in this type as an Int instead.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

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

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

Serialize as big endian bytes.

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

Serialize as little endian bytes.

Trait Implementations

impl<const LIMBS: usize> Add<&Uint<LIMBS>> for &BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: &Uint<LIMBS>) -> BoxedUint

Performs the + operation.

impl<const LIMBS: usize> Add<&Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: &Uint<LIMBS>) -> BoxedUint

Performs the + operation.

impl<const LIMBS: usize> Add<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> Add<Uint<LIMBS>> for &BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: Uint<LIMBS>) -> BoxedUint

Performs the + operation.

impl<const LIMBS: usize> Add<Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the + operator.

fn add(self, rhs: Uint<LIMBS>) -> BoxedUint

Performs the + operation.

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

type Output = Uint<LIMBS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const LIMBS: usize> AddAssign<&Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

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

Performs the += operation.

impl<const LIMBS: usize> AddAssign<&Uint<LIMBS>> for Uint<LIMBS>

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

Performs the += operation.

impl<const LIMBS: usize> AddAssign<Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

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

Performs the += operation.

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

fn add_assign(&mut self, other: Self)

Performs the += operation.

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<[u32; 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<[u32; 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> Binary for Uint<LIMBS>

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

Formats the value using the given formatter.

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

type Output = Uint<LIMBS>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = Uint<LIMBS>

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = 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> BitOps for Uint<LIMBS>

fn bits_precision(&self) -> u32

Precision of this integer in bits.

fn bytes_precision(&self) -> usize

Precision of this integer in bytes.

fn leading_zeros(&self) -> u32

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

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

Calculate the number of bits needed to represent this number.

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

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

fn trailing_zeros(&self) -> u32

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

fn trailing_ones(&self) -> u32

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

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

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

fn bits_vartime(&self) -> u32

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

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

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

fn trailing_zeros_vartime(&self) -> u32

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

fn trailing_ones_vartime(&self) -> u32

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

fn log2_bits(&self) -> u32

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

fn bits(&self) -> u32

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

fn leading_zeros_vartime(&self) -> u32

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

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

type Output = Uint<LIMBS>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = Uint<LIMBS>

The resulting type after applying the | operator.

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

Performs the | operation.

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

type Output = 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<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

type Output = Uint<LIMBS>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const LIMBS: usize> BitXor 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: u32 = Self::BITS

Size of this integer in bits.

const BYTES: usize = Self::BYTES

Size of this integer in bytes.

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

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

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

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

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

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

impl<const LIMBS: usize, const RHS_LIMBS: usize> CheckedMul<Uint<RHS_LIMBS>> for Int<LIMBS>

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

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

impl<const LIMBS: usize, const RHS_LIMBS: usize> CheckedMul<Uint<RHS_LIMBS>> for Uint<LIMBS>

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

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

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

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 Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

Available on crate feature extra-sizes only.

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

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

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

Concatenated output: combination of Self and Hi.

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

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

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most significant.

impl ConcatMixed<Uint<{ U64::LIMBS * $size }>> for Uint<{ _ }>

type MixedOutput = Uint<{ nlimbs!($bits) }>

Concatenated output: combination of Self and Hi.

fn concat_mixed(&self, hi: &Uint<{ _ }>) -> Self::MixedOutput

Concatenate the two values, with self as least significant and hi as the most 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> ConstZero for Uint<LIMBS>

const ZERO: Self = Self::ZERO

The additive identity element of Self, 0.

impl<const LIMBS: usize> ConstantTimeEq for Uint<LIMBS>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<const LIMBS: usize> ConstantTimeGreater for Uint<LIMBS>

fn ct_gt(&self, other: &Self) -> Choice

Determine whether self > other.

impl<const LIMBS: usize> ConstantTimeLess for Uint<LIMBS>

fn ct_lt(&self, other: &Self) -> Choice

Determine whether self < other.

impl<const LIMBS: usize> Constants for Uint<LIMBS>

const ONE: Self = Self::ONE

The value 1.

const MAX: Self = Self::MAX

Maximum value this integer can express.

impl<const LIMBS: usize> Debug for Uint<LIMBS>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<const LIMBS: usize> Decodable for Uint<LIMBS>

where Self: Encoding, <Self as Encoding>::Repr: Default,

Available on crate feature rlp only.

fn decode(rlp: &Rlp<'_>) -> Result<Self, DecoderError>

Decode a value from RLP bytes

impl<'a, const LIMBS: usize> DecodeValue<'a> for Uint<LIMBS>

where Uint<LIMBS>: ArrayEncoding,

Available on crate features der and hybrid-array only.

fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self>

Attempt to decode this message using the provided Reader.

impl<const LIMBS: usize> Default for Uint<LIMBS>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const LIMBS: usize> Deserialize<'de> for Uint<LIMBS>

where Uint<LIMBS>: Encoding,

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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<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<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<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<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<Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: Uint<LIMBS>) -> Self::Output

Performs the / operation.

impl<const LIMBS: usize> Div for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the / operator.

fn div(self, rhs: 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 LIMBS: usize> DivRemLimb for Uint<LIMBS>

fn div_rem_limb_with_reciprocal(&self, reciprocal: &Reciprocal) -> (Self, Limb)

Computes self / rhs, returns the quotient (q) and remainder (r).

fn div_rem_limb(&self, rhs: NonZero<Limb>) -> (Self, Limb)

Computes self / rhs using a pre-made reciprocal, returns the quotient (q) and remainder (r).

impl<const LIMBS: usize> Encodable for Uint<LIMBS>

where Self: Encoding,

Available on crate feature rlp only.

fn rlp_append(&self, stream: &mut RlpStream)

Append a value to the stream

fn rlp_bytes(&self) -> BytesMut

Get rlp-encoded bytes for this instance

impl<const LIMBS: usize> EncodeValue for Uint<LIMBS>

where Uint<LIMBS>: ArrayEncoding,

Available on crate features der and hybrid-array only.

fn value_len(&self) -> Result<Length>

Compute the length of this value (sans [Tag]+Length header) when encoded as ASN.1 DER.

fn encode_value(&self, encoder: &mut impl Writer) -> Result<()>

Encode value (sans [Tag]+Length header) as ASN.1 DER using the provided Writer.

fn header(&self) -> Result<Header, Error>

where Self: Tagged,

Get the Header used to encode this value.

impl<const LIMBS: usize> FixedInteger for Uint<LIMBS>

const LIMBS: usize = LIMBS

The number of limbs used on this platform.

impl<const LIMBS: usize> FixedTag for Uint<LIMBS>

where Uint<LIMBS>: ArrayEncoding,

Available on crate features der and hybrid-array only.

const TAG: Tag = Tag::Integer

ASN.1 tag

impl<const L: usize, const H: usize, const LIMBS: usize> From<&(Uint<L>, Uint<H>)> for Uint<LIMBS>

where Uint<L>: ConcatMixed<Uint<H>, 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<&Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

fn from(uint: &Uint<LIMBS>) -> BoxedUint

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<[u32; 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<L>: ConcatMixed<Uint<H>, 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 From<Uint<{ nlimbs!($bits) }>> for u128

fn from(n: U128) -> u128

Converts to this type from the input type.

impl From<Uint<{ nlimbs!($bits) }>> for u64

Available on 32-bit only.

fn from(n: U64) -> u64

Converts to this type from the input type.

impl<const LIMBS: usize> From<Uint<LIMBS>> for [Limb; LIMBS]

fn from(n: Uint<LIMBS>) -> [Limb; LIMBS]

Converts to this type from the input type.

impl<const LIMBS: usize> From<Uint<LIMBS>> for [Word; LIMBS]

fn from(n: Uint<LIMBS>) -> [Word; LIMBS]

Converts to this type from the input type.

impl<const L: usize, const H: usize, const LIMBS: usize> From<Uint<LIMBS>> for (Uint<L>, Uint<H>)

where Uint<LIMBS>: SplitMixed<Uint<L>, Uint<H>>,

fn from(num: Uint<LIMBS>) -> (Uint<L>, Uint<H>)

Converts to this type from the input type.

impl<const LIMBS: usize> From<Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

fn from(uint: Uint<LIMBS>) -> BoxedUint

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 SAT_LIMBS: usize, const UNSAT_LIMBS: usize> Gcd<Int<SAT_LIMBS>> for Uint<SAT_LIMBS>

where Odd<Uint<SAT_LIMBS>>: PrecomputeInverter<Inverter = SafeGcdInverter<SAT_LIMBS, UNSAT_LIMBS>>,

Gcd of a Uint and an Int.

type Output = Uint<SAT_LIMBS>

Output type.

fn gcd(&self, rhs: &Int<SAT_LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Int<SAT_LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const SAT_LIMBS: usize, const UNSAT_LIMBS: usize> Gcd<Uint<SAT_LIMBS>> for Int<SAT_LIMBS>

where Odd<Uint<SAT_LIMBS>>: PrecomputeInverter<Inverter = SafeGcdInverter<SAT_LIMBS, UNSAT_LIMBS>>,

Gcd of an Int and a Uint.

type Output = Uint<SAT_LIMBS>

Output type.

fn gcd(&self, rhs: &Uint<SAT_LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Uint<SAT_LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const SAT_LIMBS: usize, const UNSAT_LIMBS: usize> Gcd<Uint<SAT_LIMBS>> for Odd<Uint<SAT_LIMBS>>

where Odd<Self>: PrecomputeInverter<Inverter = SafeGcdInverter<SAT_LIMBS, UNSAT_LIMBS>>,

type Output = Uint<SAT_LIMBS>

Output type.

fn gcd(&self, rhs: &Uint<SAT_LIMBS>) -> Uint<SAT_LIMBS>

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Uint<SAT_LIMBS>) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<const SAT_LIMBS: usize, const UNSAT_LIMBS: usize> Gcd for Uint<SAT_LIMBS>

where Odd<Self>: PrecomputeInverter<Inverter = SafeGcdInverter<SAT_LIMBS, UNSAT_LIMBS>>,

type Output = Uint<SAT_LIMBS>

Output type.

fn gcd(&self, rhs: &Self) -> Self

Compute the greatest common divisor of self and rhs.

fn gcd_vartime(&self, rhs: &Self) -> Self::Output

Compute the greatest common divisor of self and rhs in variable time.

impl<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>

type Monty = MontyForm<LIMBS>

The corresponding Montgomery representation, optimized for the performance of modular operations at the price of a conversion overhead.

fn one() -> Self

The value 1.

fn from_limb_like(limb: Limb, _other: &Self) -> Self

Returns an integer with the first limb set to limb, and the same precision as other.

fn nlimbs(&self) -> usize

Number of limbs in this integer.

fn one_like(other: &Self) -> Self

The value 1 with the same precision as other.

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, const UNSAT_LIMBS: usize> InvMod for Uint<LIMBS>

where Odd<Self>: PrecomputeInverter<Inverter = SafeGcdInverter<LIMBS, UNSAT_LIMBS>>,

type Output = Uint<LIMBS>

Output type.

fn inv_mod(&self, modulus: &Self) -> CtOption<Self>

Compute 1 / self mod p.

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 RHS_LIMBS: usize> Mul<&Uint<RHS_LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<RHS_LIMBS>) -> Self::Output

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<&Uint<RHS_LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<RHS_LIMBS>) -> Self::Output

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<&Uint<RHS_LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<&Uint<RHS_LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Uint<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Uint<RHS_LIMBS>> for &Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Uint<RHS_LIMBS>) -> Self::Output

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Uint<RHS_LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Uint<RHS_LIMBS>) -> Self::Output

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Uint<RHS_LIMBS>> for Int<LIMBS>

type Output = Int<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Uint<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> Mul<Uint<RHS_LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the * operator.

fn mul(self, rhs: Uint<RHS_LIMBS>) -> Self

Performs the * operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> MulAssign<&Uint<RHS_LIMBS>> for Uint<LIMBS>

fn mul_assign(&mut self, rhs: &Uint<RHS_LIMBS>)

Performs the *= operation.

impl<const LIMBS: usize, const RHS_LIMBS: usize> MulAssign<Uint<RHS_LIMBS>> for Uint<LIMBS>

fn mul_assign(&mut self, rhs: Uint<RHS_LIMBS>)

Performs the *= operation.

impl<const LIMBS: usize> MulMod for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn mul_mod(&self, rhs: &Self, p: &Self) -> Self

Compute self * rhs mod p.

impl<MOD: ConstMontyParams<LIMBS>, const LIMBS: usize, const RHS_LIMBS: usize> MultiExponentiateBoundedExp<Uint<RHS_LIMBS>, [(ConstMontyForm<MOD, LIMBS>, Uint<RHS_LIMBS>)]> for ConstMontyForm<MOD, LIMBS>

Available on crate feature alloc only.

fn multi_exponentiate_bounded_exp( bases_and_exponents: &[(Self, Uint<RHS_LIMBS>)], exponent_bits: u32, ) -> Self

Calculates x1 ^ k1 * ... * xn ^ kn.

impl<const N: usize, MOD: ConstMontyParams<LIMBS>, const LIMBS: usize, const RHS_LIMBS: usize> MultiExponentiateBoundedExp<Uint<RHS_LIMBS>, [(ConstMontyForm<MOD, LIMBS>, Uint<RHS_LIMBS>); N]> for ConstMontyForm<MOD, LIMBS>

fn multi_exponentiate_bounded_exp( bases_and_exponents: &[(Self, Uint<RHS_LIMBS>); N], exponent_bits: u32, ) -> Self

Calculates x1 ^ k1 * ... * xn ^ kn.

impl<const LIMBS: usize, const RHS_LIMBS: usize> MultiExponentiateBoundedExp<Uint<RHS_LIMBS>, [(MontyForm<LIMBS>, Uint<RHS_LIMBS>)]> for MontyForm<LIMBS>

Available on crate feature alloc only.

fn multi_exponentiate_bounded_exp( bases_and_exponents: &[(Self, Uint<RHS_LIMBS>)], exponent_bits: u32, ) -> Self

Calculates x1 ^ k1 * ... * xn ^ kn.

impl<const N: usize, const LIMBS: usize, const RHS_LIMBS: usize> MultiExponentiateBoundedExp<Uint<RHS_LIMBS>, [(MontyForm<LIMBS>, Uint<RHS_LIMBS>); N]> for MontyForm<LIMBS>

fn multi_exponentiate_bounded_exp( bases_and_exponents: &[(Self, Uint<RHS_LIMBS>); N], exponent_bits: u32, ) -> Self

Calculates x1 ^ k1 * ... * xn ^ kn.

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

Performs the unary ! operation.

impl<const LIMBS: usize> Num for Uint<LIMBS>

fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

⚠️ WARNING: from_str_radix impl operates in variable-time with respect to the input.

type FromStrRadixErr = DecodeError

impl<const LIMBS: usize> One for Uint<LIMBS>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<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<Odd<Uint<LIMBS>>> for Uint<LIMBS>

fn eq(&self, other: &Odd<Uint<LIMBS>>) -> 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> 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<Odd<Uint<LIMBS>>> for Uint<LIMBS>

fn partial_cmp(&self, other: &Odd<Uint<LIMBS>>) -> 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> 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<MOD: ConstMontyParams<LIMBS>, const LIMBS: usize, const RHS_LIMBS: usize> PowBoundedExp<Uint<RHS_LIMBS>> for ConstMontyForm<MOD, LIMBS>

fn pow_bounded_exp( &self, exponent: &Uint<RHS_LIMBS>, exponent_bits: u32, ) -> Self

Raises to the exponent power, with exponent_bits representing the number of (least significant) bits to take into account for the exponent.

impl<const LIMBS: usize, const RHS_LIMBS: usize> PowBoundedExp<Uint<RHS_LIMBS>> for MontyForm<LIMBS>

fn pow_bounded_exp( &self, exponent: &Uint<RHS_LIMBS>, exponent_bits: u32, ) -> Self

Raises to the exponent power, with exponent_bits representing the number of (least significant) bits to take into account for the exponent.

impl<const LIMBS: usize> Random for Uint<LIMBS>

Available on crate feature rand_core only.

fn random(rng: &mut (impl RngCore + ?Sized)) -> Self

Generate a random value.

impl<const LIMBS: usize> RandomBits for Uint<LIMBS>

Available on crate feature rand_core only.

fn try_random_bits( rng: &mut (impl RngCore + ?Sized), bit_length: u32, ) -> Result<Self, RandomBitsError>

Generate a random value in range [0, 2^bit_length).

fn try_random_bits_with_precision( rng: &mut (impl RngCore + ?Sized), bit_length: u32, bits_precision: u32, ) -> Result<Self, RandomBitsError>

Generate a random value in range [0, 2^bit_length), returning an integer with the closest available size to bits_precision (if the implementing type supports runtime sizing).

fn random_bits(rng: &mut (impl RngCore + ?Sized), bit_length: u32) -> Self

Generate a random value in range [0, 2^bit_length).

fn random_bits_with_precision( rng: &mut (impl RngCore + ?Sized), bit_length: u32, bits_precision: u32, ) -> Self

Generate a random value in range [0, 2^bit_length), returning an integer with the closest available size to bits_precision (if the implementing type supports runtime sizing).

impl<const LIMBS: usize> RandomMod for Uint<LIMBS>

Available on crate feature rand_core only.

fn random_mod( rng: &mut (impl RngCore + ?Sized), modulus: &NonZero<Self>, ) -> Self

Generate a random number which is less than a given modulus.

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<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<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<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<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<Uint<LIMBS>> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: Uint<LIMBS>) -> Self::Output

Performs the % operation.

impl<const LIMBS: usize> Rem for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the % operator.

fn rem(self, rhs: 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> RemLimb for Uint<LIMBS>

fn rem_limb_with_reciprocal(&self, reciprocal: &Reciprocal) -> Limb

Computes self % rhs.

fn rem_limb(&self, rhs: NonZero<Limb>) -> Limb

Computes self % rhs using a pre-made reciprocal.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U192

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U192

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U384

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U384

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U448

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U448

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U448

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U448

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U448

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U448

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U512

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U512

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U256

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U512

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U512

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U512

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U512

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U256

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U576

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U640

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U320

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U704

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U320

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U768

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U320

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U320

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U832

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U384

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U896

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U384

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U960

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl RemMixed<Uint<{ U64::LIMBS * $size }>> for U1024

fn rem_mixed(&self, reductor: &NonZero<Uint<{ _ }>>) -> Uint<{ _ }>

Calculate the remainder of self by the reductor.

impl<const LIMBS: usize> Serialize for Uint<LIMBS>

where Uint<LIMBS>: Encoding,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const LIMBS: usize> Shl<i32> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> Uint<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<i32> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: i32) -> Uint<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<u32> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> Uint<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<u32> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: u32) -> Uint<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<usize> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> Uint<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> Shl<usize> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the << operator.

fn shl(self, shift: usize) -> Uint<LIMBS>

Performs the << operation.

impl<const LIMBS: usize> ShlAssign<i32> for Uint<LIMBS>

fn shl_assign(&mut self, shift: i32)

Performs the <<= operation.

impl<const LIMBS: usize> ShlAssign<u32> for Uint<LIMBS>

fn shl_assign(&mut self, shift: u32)

Performs the <<= operation.

impl<const LIMBS: usize> ShlAssign<usize> for Uint<LIMBS>

fn shl_assign(&mut self, shift: usize)

Performs the <<= operation.

impl<const LIMBS: usize> ShlVartime for Uint<LIMBS>

fn overflowing_shl_vartime(&self, shift: u32) -> CtOption<Self>

Computes self << shift.

fn wrapping_shl_vartime(&self, shift: u32) -> Self

Computes self << shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl<const LIMBS: usize> Shr<i32> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> Uint<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<i32> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: i32) -> Uint<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<u32> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> Uint<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<u32> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: u32) -> Uint<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<usize> for &Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> Uint<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> Shr<usize> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the >> operator.

fn shr(self, shift: usize) -> Uint<LIMBS>

Performs the >> operation.

impl<const LIMBS: usize> ShrAssign<i32> for Uint<LIMBS>

fn shr_assign(&mut self, shift: i32)

Performs the >>= operation.

impl<const LIMBS: usize> ShrAssign<u32> for Uint<LIMBS>

fn shr_assign(&mut self, shift: u32)

Performs the >>= operation.

impl<const LIMBS: usize> ShrAssign<usize> for Uint<LIMBS>

fn shr_assign(&mut self, shift: usize)

Performs the >>= operation.

impl<const LIMBS: usize> ShrVartime for Uint<LIMBS>

fn overflowing_shr_vartime(&self, shift: u32) -> CtOption<Self>

Computes self >> shift.

fn wrapping_shr_vartime(&self, shift: u32) -> Self

Computes self >> shift in a panic-free manner, masking off bits of shift which would cause the shift to exceed the type’s width.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U64

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1152

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1408

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1664

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U1920

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2176

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2304

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2432

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2560

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2688

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high 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 low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2816

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U2944

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3200

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3328

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3456

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3712

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3840

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U3968

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4480

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4608

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high 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 low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4736

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4864

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U4992

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U5120

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U5248

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U5376

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U5504

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U5632

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U5760

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U5888

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high 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 low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6016

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6272

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6400

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6528

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6656

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6784

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U6912

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7040

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7168

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7296

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high 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 low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7424

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7552

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7680

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7808

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U7936

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high components respectively.

impl SplitMixed<Uint<{ <$name>::LIMBS / 2 }>, Uint<{ <$name>::LIMBS / 2 }>> for U8064

Available on crate feature extra-sizes only.

fn split_mixed(&self) -> (Uint<{ _ }>, Uint<{ _ }>)

Split this number into parts, returning its low and high 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 low and high components respectively.

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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high 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 low and high components respectively.

impl<const LIMBS: usize> SquareRoot for Uint<LIMBS>

fn sqrt(&self) -> Self

Computes floor(sqrt(self)).

fn sqrt_vartime(&self) -> Self

Computes floor(sqrt(self)), variable time in self.

impl<const LIMBS: usize> Sub<&Uint<LIMBS>> for &BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: &Uint<LIMBS>) -> BoxedUint

Performs the - operation.

impl<const LIMBS: usize> Sub<&Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: &Uint<LIMBS>) -> BoxedUint

Performs the - operation.

impl<const LIMBS: usize> Sub<&Uint<LIMBS>> for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: &Self) -> Self

Performs the - operation.

impl<const LIMBS: usize> Sub<Uint<LIMBS>> for &BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: Uint<LIMBS>) -> BoxedUint

Performs the - operation.

impl<const LIMBS: usize> Sub<Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

type Output = BoxedUint

The resulting type after applying the - operator.

fn sub(self, rhs: Uint<LIMBS>) -> BoxedUint

Performs the - operation.

impl<const LIMBS: usize> Sub for Uint<LIMBS>

type Output = Uint<LIMBS>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<const LIMBS: usize> SubAssign<&Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

fn sub_assign(&mut self, rhs: &Uint<LIMBS>)

Performs the -= operation.

impl<const LIMBS: usize> SubAssign<&Uint<LIMBS>> for Uint<LIMBS>

fn sub_assign(&mut self, rhs: &Uint<LIMBS>)

Performs the -= operation.

impl<const LIMBS: usize> SubAssign<Uint<LIMBS>> for BoxedUint

Available on crate feature alloc only.

fn sub_assign(&mut self, rhs: Uint<LIMBS>)

Performs the -= operation.

impl<const LIMBS: usize> SubAssign for Uint<LIMBS>

fn sub_assign(&mut self, rhs: Uint<LIMBS>)

Performs the -= operation.

impl<const LIMBS: usize> SubMod for Uint<LIMBS>

type Output = Uint<LIMBS>

Output type.

fn sub_mod(&self, rhs: &Self, p: &Self) -> Self

Compute self - rhs mod p.

impl<'a, const LIMBS: usize> TryFrom<AnyRef<'a>> for Uint<LIMBS>

where Uint<LIMBS>: ArrayEncoding,

Available on crate features der and hybrid-array only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(any: AnyRef<'a>) -> Result<Uint<LIMBS>>

Performs the conversion.

impl<'a, const LIMBS: usize> TryFrom<UintRef<'a>> for Uint<LIMBS>

where Uint<LIMBS>: ArrayEncoding,

Available on crate features der and hybrid-array only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(bytes: UintRef<'a>) -> Result<Uint<LIMBS>>

Performs the conversion.

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, const RHS_LIMBS: usize, const WIDE_LIMBS: usize> WideningMul<&Uint<RHS_LIMBS>> for Uint<LIMBS>

where Self: ConcatMixed<Uint<RHS_LIMBS>, MixedOutput = Uint<WIDE_LIMBS>>,

type Output = <Uint<LIMBS> as ConcatMixed<Uint<RHS_LIMBS>>>::MixedOutput

Output of the widening multiplication.

fn widening_mul(&self, rhs: &Uint<RHS_LIMBS>) -> Self::Output

Perform widening multiplication.

impl<const LIMBS: usize, const RHS_LIMBS: usize, const WIDE_LIMBS: usize> WideningMul<Uint<RHS_LIMBS>> for Uint<LIMBS>

where Self: ConcatMixed<Uint<RHS_LIMBS>, MixedOutput = Uint<WIDE_LIMBS>>,

type Output = <Uint<LIMBS> as ConcatMixed<Uint<RHS_LIMBS>>>::MixedOutput

Output of the widening multiplication.

fn widening_mul(&self, rhs: Uint<RHS_LIMBS>) -> Self::Output

Perform widening multiplication.

impl<const LIMBS: usize> WrappingAdd for Uint<LIMBS>

fn wrapping_add(&self, v: &Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<const LIMBS: usize> WrappingMul for Uint<LIMBS>

fn wrapping_mul(&self, v: &Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<const LIMBS: usize> WrappingNeg for Uint<LIMBS>

fn wrapping_neg(&self) -> Self

Wrapping (modular) negation. Computes -self, wrapping around at the boundary of the type.

impl<const LIMBS: usize> WrappingShl for Uint<LIMBS>

fn wrapping_shl(&self, shift: u32) -> Uint<LIMBS>

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<const LIMBS: usize> WrappingShr for Uint<LIMBS>

fn wrapping_shr(&self, shift: u32) -> Uint<LIMBS>

Panic-free bitwise shift-right; yields self >> mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<const LIMBS: usize> WrappingSub for Uint<LIMBS>

fn wrapping_sub(&self, v: &Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<const LIMBS: usize> Zero for Uint<LIMBS>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<const LIMBS: usize> Copy for Uint<LIMBS>

impl<const LIMBS: usize> DefaultIsZeroes for Uint<LIMBS>

Available on crate feature zeroize only.

impl<const LIMBS: usize> Eq for Uint<LIMBS>