reth::revm::revm::primitives::alloy_primitives

Type Alias U256

Help

pub type U256 = Uint<256, 4>;

Expand description

256-bit unsigned integer type, consisting of 4, 64-bit limbs.

Aliased Type§

struct U256 { /* private fields */ }

Layout§

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes

Implementations

§

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

pub fn abs_diff(self, other: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes the absolute difference between self and other.

Returns $\left\vert \mathtt{self} - \mathtt{other} \right\vert$.

pub const fn checked_add( self, rhs: Uint<BITS, LIMBS>, ) -> Option<Uint<BITS, LIMBS>>

Computes self + rhs, returning None if overflow occurred.

pub const fn checked_neg(self) -> Option<Uint<BITS, LIMBS>>

Computes -self, returning None unless self == 0.

pub const fn checked_sub( self, rhs: Uint<BITS, LIMBS>, ) -> Option<Uint<BITS, LIMBS>>

Computes self - rhs, returning None if overflow occurred.

pub const fn overflowing_add( self, rhs: Uint<BITS, LIMBS>, ) -> (Uint<BITS, LIMBS>, bool)

Calculates $\mod{\mathtt{self} + \mathtt{rhs}}_{2^{BITS}}$.

Returns a tuple of the addition along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

pub const fn overflowing_neg(self) -> (Uint<BITS, LIMBS>, bool)

Calculates $\mod{-\mathtt{self}}_{2^{BITS}}$.

Returns !self + 1 using wrapping operations to return the value that represents the negation of this unsigned value. Note that for positive unsigned values overflow always occurs, but negating 0 does not overflow.

pub const fn overflowing_sub( self, rhs: Uint<BITS, LIMBS>, ) -> (Uint<BITS, LIMBS>, bool)

Calculates $\mod{\mathtt{self} - \mathtt{rhs}}_{2^{BITS}}$.

Returns a tuple of the subtraction along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

pub const fn saturating_add(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub const fn saturating_sub(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self - rhs, saturating at the numeric bounds instead of overflowing

pub const fn wrapping_add(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self + rhs, wrapping around at the boundary of the type.

pub const fn wrapping_neg(self) -> Uint<BITS, LIMBS>

Computes -self, wrapping around at the boundary of the type.

pub const fn wrapping_sub(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self - rhs, wrapping around at the boundary of the type.

§

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

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

Returns whether a specific bit is set.

Returns false if index exceeds the bit width of the number.

pub fn set_bit(&mut self, index: usize, value: bool)

Sets a specific bit to a value.

pub const fn byte(&self, index: usize) -> u8

Returns a specific byte. The byte at index 0 is the least significant byte (little endian).

§Panics

Panics if index is greater than or equal to the byte width of the number.

§Examples

let x = uint!(0x1234567890_U64);
let bytes = [
    x.byte(0), // 0x90
    x.byte(1), // 0x78
    x.byte(2), // 0x56
    x.byte(3), // 0x34
    x.byte(4), // 0x12
    x.byte(5), // 0x00
    x.byte(6), // 0x00
    x.byte(7), // 0x00
];
assert_eq!(bytes, x.to_le_bytes());

Panics if out of range.

let x = uint!(0x1234567890_U64);
let _ = x.byte(8);

pub fn checked_byte(&self, index: usize) -> Option<u8>

Returns a specific byte, or None if index is out of range. The byte at index 0 is the least significant byte (little endian).

§Examples

let x = uint!(0x1234567890_U64);
assert_eq!(x.checked_byte(0), Some(0x90));
// Out of range
assert_eq!(x.checked_byte(8), None);

pub fn reverse_bits(self) -> Uint<BITS, LIMBS>

Reverses the order of bits in the integer. The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.

pub fn leading_zeros(&self) -> usize

Returns the number of leading zeros in the binary representation of self.

pub fn leading_ones(&self) -> usize

Returns the number of leading ones in the binary representation of self.

pub fn trailing_zeros(&self) -> usize

Returns the number of trailing zeros in the binary representation of self.

pub fn trailing_ones(&self) -> usize

Returns the number of trailing ones in the binary representation of self.

pub fn count_ones(&self) -> usize

Returns the number of ones in the binary representation of self.

pub fn count_zeros(&self) -> usize

Returns the number of zeros in the binary representation of self.

pub fn bit_len(&self) -> usize

Length of the number in bits ignoring leading zeros.

pub fn byte_len(&self) -> usize

Length of the number in bytes ignoring leading zeros.

pub fn most_significant_bits(&self) -> (u64, usize)

Returns the most significant 64 bits of the number and the exponent.

Given return value $(\mathtt{bits}, \mathtt{exponent})$, the self can be approximated as

$$ \mathtt{self} ≈ \mathtt{bits} ⋅ 2^\mathtt{exponent} $$

If self is $<≥> 2^{63}$, then exponent will be zero and bits will have leading zeros.

pub fn checked_shl(self, rhs: usize) -> Option<Uint<BITS, LIMBS>>

Checked left shift by rhs bits.

Returns $\mathtt{self} ⋅ 2^{\mathtt{rhs}}$ or None if the result would $≥ 2^{\mathtt{BITS}}$. That is, it returns None if the bits shifted out would be non-zero.

Note: This differs from u64::checked_shl which returns None if the shift is larger than BITS (which is IMHO not very useful).

pub fn saturating_shl(self, rhs: usize) -> Uint<BITS, LIMBS>

Saturating left shift by rhs bits.

Returns $\mathtt{self} ⋅ 2^{\mathtt{rhs}}$ or Uint::MAX if the result would $≥ 2^{\mathtt{BITS}}$. That is, it returns Uint::MAX if the bits shifted out would be non-zero.

pub fn overflowing_shl(self, rhs: usize) -> (Uint<BITS, LIMBS>, bool)

Left shift by rhs bits with overflow detection.

Returns $\mod{\mathtt{value} ⋅ 2^{\mathtt{rhs}}}_{2^{\mathtt{BITS}}}$. If the product is $≥ 2^{\mathtt{BITS}}$ it returns true. That is, it returns true if the bits shifted out are non-zero.

Note: This differs from u64::overflowing_shl which returns true if the shift is larger than BITS (which is IMHO not very useful).

pub fn wrapping_shl(self, rhs: usize) -> Uint<BITS, LIMBS>

Left shift by rhs bits.

Returns $\mod{\mathtt{value} ⋅ 2^{\mathtt{rhs}}}_{2^{\mathtt{BITS}}}$.

Note: This differs from u64::wrapping_shl which first reduces rhs by BITS (which is IMHO not very useful).

pub fn checked_shr(self, rhs: usize) -> Option<Uint<BITS, LIMBS>>

Checked right shift by rhs bits.

$$ \frac{\mathtt{self}}{2^{\mathtt{rhs}}} $$

Returns the above or None if the division is not exact. This is the same as

Note: This differs from u64::checked_shr which returns None if the shift is larger than BITS (which is IMHO not very useful).

pub fn overflowing_shr(self, rhs: usize) -> (Uint<BITS, LIMBS>, bool)

Right shift by rhs bits with underflow detection.

$$ \floor{\frac{\mathtt{self}}{2^{\mathtt{rhs}}}} $$

Returns the above and false if the division was exact, and true if it was rounded down. This is the same as non-zero bits being shifted out.

Note: This differs from u64::overflowing_shr which returns true if the shift is larger than BITS (which is IMHO not very useful).

pub fn wrapping_shr(self, rhs: usize) -> Uint<BITS, LIMBS>

Right shift by rhs bits.

$$ \mathtt{wrapping\_shr}(\mathtt{self}, \mathtt{rhs}) = \floor{\frac{\mathtt{self}}{2^{\mathtt{rhs}}}} $$

Note: This differs from u64::wrapping_shr which first reduces rhs by BITS (which is IMHO not very useful).

pub fn arithmetic_shr(self, rhs: usize) -> Uint<BITS, LIMBS>

Arithmetic shift right by rhs bits.

pub fn rotate_left(self, rhs: usize) -> Uint<BITS, LIMBS>

Shifts the bits to the left by a specified amount, rhs, wrapping the truncated bits to the end of the resulting integer.

pub fn rotate_right(self, rhs: usize) -> Uint<BITS, LIMBS>

Shifts the bits to the right by a specified amount, rhs, wrapping the truncated bits to the beginning of the resulting integer.

§

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

pub fn checked_div(self, rhs: Uint<BITS, LIMBS>) -> Option<Uint<BITS, LIMBS>>

Computes self / rhs, returning None if rhs == 0.

pub fn checked_rem(self, rhs: Uint<BITS, LIMBS>) -> Option<Uint<BITS, LIMBS>>

Computes self % rhs, returning None if rhs == 0.

pub fn div_ceil(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self / rhs rounding up.

§Panics

Panics if rhs == 0.

pub fn div_rem( self, rhs: Uint<BITS, LIMBS>, ) -> (Uint<BITS, LIMBS>, Uint<BITS, LIMBS>)

Computes self / rhs and self % rhs.

§Panics

Panics if rhs == 0.

pub fn wrapping_div(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self / rhs rounding down.

§Panics

Panics if rhs == 0.

pub fn wrapping_rem(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self % rhs.

§Panics

Panics if rhs == 0.

§

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

pub fn checked_log(self, base: Uint<BITS, LIMBS>) -> Option<usize>

Returns the logarithm of the number, rounded down.

Returns None if the base is less than two, or this number is zero.

pub fn checked_log10(self) -> Option<usize>

Returns the base 10 logarithm of the number, rounded down.

Returns None if the number is zero.

pub fn checked_log2(self) -> Option<usize>

Returns the base 2 logarithm of the number, rounded down.

This is equivalent to the index of the highest set bit.

Returns None if the number is zero.

pub fn log(self, base: Uint<BITS, LIMBS>) -> usize

Returns the logarithm of the number, rounded down.

§Panics

Panics if the base is less than 2 or if the number is zero.

pub fn log10(self) -> usize

Returns the base 10 logarithm of the number, rounded down.

§Panics

Panics if the base if the number is zero.

pub fn log2(self) -> usize

Returns the base 2 logarithm of the number, rounded down.

§Panics

Panics if the base if the number is zero.

pub fn approx_log(self, base: f64) -> f64

Double precision logarithm.

pub fn approx_log2(self) -> f64

Double precision binary logarithm.

§Examples

assert_eq!(0_U64.approx_log2(), f64::NEG_INFINITY);
assert_eq!(1_U64.approx_log2(), 0.0);
assert_eq!(2_U64.approx_log2(), 1.0);
assert_eq!(U64::MAX.approx_log2(), 64.0);

pub fn approx_log10(self) -> f64

Double precision decimal logarithm.

§

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

pub fn checked_mul(self, rhs: Uint<BITS, LIMBS>) -> Option<Uint<BITS, LIMBS>>

Computes self * rhs, returning None if overflow occurred.

pub fn overflowing_mul( self, rhs: Uint<BITS, LIMBS>, ) -> (Uint<BITS, LIMBS>, bool)

Calculates the multiplication of self and rhs.

Returns a tuple of the multiplication along with a boolean indicating whether an arithmetic overflow would occur. If an overflow would have occurred then the wrapped value is returned.

§Examples

assert_eq!(1_U1.overflowing_mul(1_U1), (1_U1, false));
assert_eq!(
    0x010000000000000000_U65.overflowing_mul(0x010000000000000000_U65),
    (0x000000000000000000_U65, true)
);

pub fn saturating_mul(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_mul(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Computes self * rhs, wrapping around at the boundary of the type.

pub fn inv_ring(self) -> Option<Uint<BITS, LIMBS>>

Computes the inverse modulo $2^{\mathtt{BITS}}$ of self, returning None if the inverse does not exist.

pub fn widening_mul<const BITS_RHS: usize, const LIMBS_RHS: usize, const BITS_RES: usize, const LIMBS_RES: usize>( self, rhs: Uint<BITS_RHS, LIMBS_RHS>, ) -> Uint<BITS_RES, LIMBS_RES>

Calculates the complete product self * rhs without the possibility to overflow.

The argument rhs can be any size Uint, the result size is the sum of the bit-sizes of self and rhs.

§Panics

This function will runtime panic of the const generic arguments are incorrect.

§Examples

assert_eq!(0_U0.widening_mul(0_U0), 0_U0);
assert_eq!(1_U1.widening_mul(1_U1), 1_U2);
assert_eq!(3_U2.widening_mul(7_U3), 21_U5);

§

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

pub fn checked_pow(self, exp: Uint<BITS, LIMBS>) -> Option<Uint<BITS, LIMBS>>

Raises self to the power of exp.

Returns None if the result would overflow.

pub fn overflowing_pow( self, exp: Uint<BITS, LIMBS>, ) -> (Uint<BITS, LIMBS>, bool)

Raises self to the power of exp and if the result would overflow.

§Examples

assert_eq!(
    36_U64.overflowing_pow(12_U64),
    (0x41c21cb8e1000000_U64, false)
);
assert_eq!(
    36_U64.overflowing_pow(13_U64),
    (0x3f4c09ffa4000000_U64, true)
);
assert_eq!(
    36_U68.overflowing_pow(13_U68),
    (0x093f4c09ffa4000000_U68, false)
);
assert_eq!(16_U65.overflowing_pow(32_U65), (0_U65, true));

Small cases:

assert_eq!(0_U0.overflowing_pow(0_U0), (0_U0, false));
assert_eq!(0_U1.overflowing_pow(0_U1), (1_U1, false));
assert_eq!(0_U1.overflowing_pow(1_U1), (0_U1, false));
assert_eq!(1_U1.overflowing_pow(0_U1), (1_U1, false));
assert_eq!(1_U1.overflowing_pow(1_U1), (1_U1, false));

pub fn pow(self, exp: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Raises self to the power of exp, wrapping around on overflow.

pub fn saturating_pow(self, exp: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Raises self to the power of exp, saturating on overflow.

pub fn wrapping_pow(self, exp: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Raises self to the power of exp, wrapping around on overflow.

pub fn approx_pow2(exp: f64) -> Option<Uint<BITS, LIMBS>>

Available on crate feature std only.

Construct from double precision binary logarithm.

§Examples

assert_eq!(U64::approx_pow2(-2.0), Some(0_U64));
assert_eq!(U64::approx_pow2(-1.0), Some(1_U64));
assert_eq!(U64::approx_pow2(0.0), Some(1_U64));
assert_eq!(U64::approx_pow2(1.0), Some(2_U64));
assert_eq!(U64::approx_pow2(1.6), Some(3_U64));
assert_eq!(U64::approx_pow2(2.0), Some(4_U64));
assert_eq!(U64::approx_pow2(64.0), None);
assert_eq!(U64::approx_pow2(10.385), Some(1337_U64));

§

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

pub fn from<T>(value: T) -> Uint<BITS, LIMBS>
where Uint<BITS, LIMBS>: UintTryFrom<T>,

Construct a new Uint from the value.

§Panics

Panics if the conversion fails, for example if the value is too large for the bit-size of the Uint. The panic will be attributed to the call site.

§Examples

assert_eq!(U8::from(142_u16), 142_U8);
assert_eq!(U64::from(0x7014b4c2d1f2_U256), 0x7014b4c2d1f2_U64);
assert_eq!(U64::from(3.145), 3_U64);

pub fn saturating_from<T>(value: T) -> Uint<BITS, LIMBS>
where Uint<BITS, LIMBS>: UintTryFrom<T>,

Construct a new Uint from the value saturating the value to the minimum or maximum value of the Uint.

If the value is not a number (like f64::NAN), then the result is set zero.

§Examples

assert_eq!(U8::saturating_from(300_u16), 255_U8);
assert_eq!(U8::saturating_from(-10_i16), 0_U8);
assert_eq!(U32::saturating_from(0x7014b4c2d1f2_U256), U32::MAX);

pub fn wrapping_from<T>(value: T) -> Uint<BITS, LIMBS>
where Uint<BITS, LIMBS>: UintTryFrom<T>,

Construct a new Uint from the value saturating the value to the minimum or maximum value of the Uint.

If the value is not a number (like f64::NAN), then the result is set zero.

§Examples

assert_eq!(U8::wrapping_from(300_u16), 44_U8);
assert_eq!(U8::wrapping_from(-10_i16), 246_U8);
assert_eq!(U32::wrapping_from(0x7014b4c2d1f2_U256), 0xb4c2d1f2_U32);

pub fn to<T>(&self) -> T
where Uint<BITS, LIMBS>: UintTryTo<T>, T: Debug,

§Panics

Panics if the conversion fails, for example if the value is too large for the bit-size of the target type.

§Examples

assert_eq!(300_U12.to::<i16>(), 300_i16);
assert_eq!(300_U12.to::<U256>(), 300_U256);

pub fn wrapping_to<T>(&self) -> T
where Uint<BITS, LIMBS>: UintTryTo<T>,

§Examples

assert_eq!(300_U12.wrapping_to::<i8>(), 44_i8);
assert_eq!(255_U32.wrapping_to::<i8>(), -1_i8);
assert_eq!(0x1337cafec0d3_U256.wrapping_to::<U32>(), 0xcafec0d3_U32);

pub fn saturating_to<T>(&self) -> T
where Uint<BITS, LIMBS>: UintTryTo<T>,

§Examples

assert_eq!(300_U12.saturating_to::<i16>(), 300_i16);
assert_eq!(255_U32.saturating_to::<i8>(), 127);
assert_eq!(0x1337cafec0d3_U256.saturating_to::<U32>(), U32::MAX);

§

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

pub fn from_str_radix( src: &str, radix: u64, ) -> Result<Uint<BITS, LIMBS>, ParseError>

Parse a string into a Uint.

For bases 2 to 36, the case-agnostic alphabet 0—1, a—b is used and _ are ignored. For bases 37 to 64, the case-sensitive alphabet a—z, A—Z, 0—9, {+-}, {/,_} is used. That is, for base 64 it is compatible with all the common base64 variants.

§Errors

ParseError::InvalidDigit if the string contains a non-digit.
ParseError::InvalidRadix if the radix is larger than 64.
ParseError::BaseConvertError if Uint::from_base_be fails.

§

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

pub fn gcd(self, other: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Compute the greatest common divisor of two Uints.

§Examples

assert_eq!(0_U128.gcd(0_U128), 0_U128);

pub fn lcm(self, other: Uint<BITS, LIMBS>) -> Option<Uint<BITS, LIMBS>>

Compute the least common multiple of two Uints or None if the result would be too large.

pub fn gcd_extended( self, other: Uint<BITS, LIMBS>, ) -> (Uint<BITS, LIMBS>, Uint<BITS, LIMBS>, Uint<BITS, LIMBS>, bool)

⚠️ Compute the greatest common divisor and the Bézout coefficients.

Warning. This is API is unstable and may change in a minor release.

Returns $(\mathtt{gcd}, \mathtt{x}, \mathtt{y}, \mathtt{sign})$ such that

$$ \gcd(\mathtt{self}, \mathtt{other}) = \mathtt{gcd} = \begin{cases} \mathtt{self} · \mathtt{x} - \mathtt{other} . \mathtt{y} & \mathtt{sign} \\ \mathtt{other} · \mathtt{y} - \mathtt{self} · \mathtt{x} & ¬\mathtt{sign} \end{cases} $$

Note that the intermediate products may overflow, even though the result after subtraction will fit in the bit size of the Uint.

§

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

pub fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some k.

pub fn next_power_of_two(self) -> Uint<BITS, LIMBS>

Returns the smallest power of two greater than or equal to self.

§Panics

Panics if the value overlfows.

pub fn checked_next_power_of_two(self) -> Option<Uint<BITS, LIMBS>>

Returns the smallest power of two greater than or equal to self. If the next power of two is greater than the type’s maximum value, None is returned, otherwise the power of two is wrapped in Some.

§Examples

assert_eq!(0_U64.checked_next_power_of_two(), Some(1_U64));
assert_eq!(1_U64.checked_next_power_of_two(), Some(1_U64));
assert_eq!(2_U64.checked_next_power_of_two(), Some(2_U64));
assert_eq!(3_U64.checked_next_power_of_two(), Some(4_U64));
assert_eq!(U64::MAX.checked_next_power_of_two(), None);

§

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

pub fn is_zero(&self) -> bool

Returns true if the value is zero.

§

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

pub fn next_multiple_of(self, rhs: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Calculates the smallest value greater than or equal to self that is a multiple of rhs.

§Panics

This function will panic if rhs is 0 or the operation results in overflow.

pub fn checked_next_multiple_of( self, rhs: Uint<BITS, LIMBS>, ) -> Option<Uint<BITS, LIMBS>>

Calculates the smallest value greater than or equal to self that is a multiple of rhs. Returns None is rhs is zero or the operation would result in overflow.

§Examples

assert_eq!(16_U64.checked_next_multiple_of(8_U64), Some(16_U64));
assert_eq!(23_U64.checked_next_multiple_of(8_U64), Some(24_U64));
assert_eq!(1_U64.checked_next_multiple_of(0_U64), None);
assert_eq!(U64::MAX.checked_next_multiple_of(2_U64), None);
}

assert_eq!(0_U0.checked_next_multiple_of(0_U0), None);
assert_eq!(0_U1.checked_next_multiple_of(0_U1), None);
assert_eq!(0_U1.checked_next_multiple_of(1_U1), Some(0_U1));
assert_eq!(1_U1.checked_next_multiple_of(0_U1), None);
assert_eq!(1_U1.checked_next_multiple_of(1_U1), Some(1_U1));
}

§

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

pub fn reduce_mod(self, modulus: Uint<BITS, LIMBS>) -> Uint<BITS, LIMBS>

⚠️ Compute $\mod{\mathtt{self}}_{\mathtt{modulus}}$.

Warning. This function is not part of the stable API.

Returns zero if the modulus is zero.

pub fn add_mod( self, rhs: Uint<BITS, LIMBS>, modulus: Uint<BITS, LIMBS>, ) -> Uint<BITS, LIMBS>

Compute $\mod{\mathtt{self} + \mathtt{rhs}}_{\mathtt{modulus}}$.

Returns zero if the modulus is zero.

pub fn mul_mod( self, rhs: Uint<BITS, LIMBS>, modulus: Uint<BITS, LIMBS>, ) -> Uint<BITS, LIMBS>

Compute $\mod{\mathtt{self} ⋅ \mathtt{rhs}}_{\mathtt{modulus}}$.

Returns zero if the modulus is zero.

See mul_redc for a faster variant at the cost of some pre-computation.

pub fn pow_mod( self, exp: Uint<BITS, LIMBS>, modulus: Uint<BITS, LIMBS>, ) -> Uint<BITS, LIMBS>

Compute $\mod{\mathtt{self}^{\mathtt{rhs}}}_{\mathtt{modulus}}$.

Returns zero if the modulus is zero.

pub fn inv_mod(self, modulus: Uint<BITS, LIMBS>) -> Option<Uint<BITS, LIMBS>>

Compute $\mod{\mathtt{self}^{-1}}_{\mathtt{modulus}}$.

Returns None if the inverse does not exist.

pub fn mul_redc( self, other: Uint<BITS, LIMBS>, modulus: Uint<BITS, LIMBS>, inv: u64, ) -> Uint<BITS, LIMBS>

Montgomery multiplication.

Requires self and other to be less than modulus.

Computes

$$ \mod{\frac{\mathtt{self} ⋅ \mathtt{other}}{ 2^{64 · \mathtt{LIMBS}}}}_{\mathtt{modulus}} $$

This is useful because it can be computed notably faster than mul_mod. Many computations can be done by pre-multiplying values with $R = 2^{64 · \mathtt{LIMBS}}$ and then using mul_redc instead of mul_mod.

For this algorithm to work, it needs an extra parameter inv which must be set to

$$ \mathtt{inv} = \mod{\frac{-1}{\mathtt{modulus}} }_{2^{64}} $$

The inv value only exists for odd values of modulus. It can be computed using inv_ring from U64.

let inv = U64::wrapping_from(modulus).inv_ring().unwrap().wrapping_neg().to();
let prod = 5_U256.mul_redc(6_U256, modulus, inv);

§Panics

Panics if inv is not correct in debug mode.

pub fn square_redc( self, modulus: Uint<BITS, LIMBS>, inv: u64, ) -> Uint<BITS, LIMBS>

Montgomery squaring.

See Self::mul_redc.

§

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

pub fn root(self, degree: usize) -> Uint<BITS, LIMBS>

Computes the floor of the degree-th root of the number.

$$ \floor{\sqrt[\mathtt{degree}]{\mathtt{self}}} $$

§Panics

Panics if degree is zero.

§Examples

assert_eq!(0_U64.root(2), 0_U64);
assert_eq!(1_U64.root(63), 1_U64);
assert_eq!(0x0032da8b0f88575d_U63.root(64), 1_U63);
assert_eq!(0x1756800000000000_U63.root(34), 3_U63);

§

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

pub fn to_base_le(&self, base: u64) -> impl Iterator<Item = u64>

Returns an iterator over the base base digits of the number in little-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

§Panics

Panics if the base is less than 2.

pub fn to_base_be(&self, base: u64) -> impl Iterator<Item = u64>

Available on crate feature alloc only.

Returns an iterator over the base base digits of the number in big-endian order.

Pro tip: instead of setting base = 10, set it to the highest power of 10 that still fits u64. This way much fewer iterations are required to extract all the digits.

§Panics

Panics if the base is less than 2.

pub fn from_base_le( base: u64, digits: I, ) -> Result<Uint<BITS, LIMBS>, BaseConvertError>
where I: IntoIterator<Item = u64>,

Constructs the Uint from digits in the base base in little-endian.

§Errors

BaseConvertError::InvalidBase if the base is less than 2.
BaseConvertError::InvalidDigit if a digit is out of range.
BaseConvertError::Overflow if the number is too large to fit.

pub fn from_base_be( base: u64, digits: I, ) -> Result<Uint<BITS, LIMBS>, BaseConvertError>
where I: IntoIterator<Item = u64>,

Constructs the Uint from digits in the base base in big-endian.

§Errors

BaseConvertError::InvalidBase if the base is less than 2.
BaseConvertError::InvalidDigit if a digit is out of range.
BaseConvertError::Overflow if the number is too large to fit.

§

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

pub const BYTES: usize

The size of this integer type in bytes. Note that some bits may be forced zero if BITS is not cleanly divisible by eight.

pub const fn as_le_slice(&self) -> &[u8] ⓘ

Available on little-endian only.

Access the underlying store as a little-endian slice of bytes.

Only available on little-endian targets.

If BITS does not evenly divide 8, it is padded with zero bits in the most significant position.

pub unsafe fn as_le_slice_mut(&mut self) -> &mut [u8] ⓘ

Available on little-endian only.

Access the underlying store as a mutable little-endian slice of bytes.

Only available on litte-endian targets.

§Safety

If BITS does not evenly divide 8, it is padded with zero bits in the most significant position. Setting those bits puts the Uint in an invalid state.

pub fn as_le_bytes(&self) -> Cow<'_, [u8]>

Available on crate feature alloc only.

Access the underlying store as a little-endian bytes.

Uses an optimized implementation on little-endian targets.

pub fn as_le_bytes_trimmed(&self) -> Cow<'_, [u8]>

Available on crate feature alloc only.

Access the underlying store as a little-endian bytes with trailing zeros removed.

Uses an optimized implementation on little-endian targets.

pub const fn to_le_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a little-endian byte array of size exactly Self::BYTES.

§Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_le_bytes_vec(&self) -> Vec<u8> ⓘ

Available on crate feature alloc only.

Converts the Uint to a little-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_le_bytes can not be used because byte size is not known compile time.

pub fn to_le_bytes_trimmed_vec(&self) -> Vec<u8> ⓘ

Available on crate feature alloc only.

Converts the Uint to a little-endian byte vector with trailing zeros bytes removed.

pub const fn to_be_bytes<const BYTES: usize>(&self) -> [u8; BYTES]

Converts the Uint to a big-endian byte array of size exactly Self::BYTES.

§Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

pub fn to_be_bytes_vec(&self) -> Vec<u8> ⓘ

Available on crate feature alloc only.

Converts the Uint to a big-endian byte vector of size exactly Self::BYTES.

This method is useful when Self::to_be_bytes can not be used because byte size is not known compile time.

pub fn to_be_bytes_trimmed_vec(&self) -> Vec<u8> ⓘ

Available on crate feature alloc only.

Converts the Uint to a big-endian byte vector with leading zeros bytes removed.

pub const fn from_be_bytes<const BYTES: usize>( bytes: [u8; BYTES], ) -> Uint<BITS, LIMBS>

Converts a big-endian byte array of size exactly Self::BYTES to Uint.

§Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

Panics if the value is too large for the bit-size of the Uint.

pub const fn from_be_slice(bytes: &[u8]) -> Uint<BITS, LIMBS>

Creates a new integer from a big endian slice of bytes.

The slice is interpreted as a big endian number. Leading zeros are ignored. The slice can be any length.

§Panics

Panics if the value is larger than fits the Uint.

pub const fn try_from_be_slice(bytes: &[u8]) -> Option<Uint<BITS, LIMBS>>

Creates a new integer from a big endian slice of bytes.

The slice is interpreted as a big endian number. Leading zeros are ignored. The slice can be any length.

Returns None if the value is larger than fits the Uint.

pub const fn from_le_bytes<const BYTES: usize>( bytes: [u8; BYTES], ) -> Uint<BITS, LIMBS>

Converts a little-endian byte array of size exactly Self::BYTES to Uint.

§Panics

Panics if the generic parameter BYTES is not exactly Self::BYTES. Ideally this would be a compile time error, but this is blocked by Rust issue #60551.

Panics if the value is too large for the bit-size of the Uint.

pub const fn from_le_slice(bytes: &[u8]) -> Uint<BITS, LIMBS>

Creates a new integer from a little endian slice of bytes.

The slice is interpreted as a little endian number. Leading zeros are ignored. The slice can be any length.

§Panics

Panics if the value is larger than fits the Uint.

pub const fn try_from_le_slice(bytes: &[u8]) -> Option<Uint<BITS, LIMBS>>

Creates a new integer from a little endian slice of bytes.

The slice is interpreted as a little endian number. Leading zeros are ignored. The slice can be any length.

Returns None if the value is larger than fits the Uint.

pub fn copy_le_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

§Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

§Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_le_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the little-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

§Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn copy_be_bytes_to(&self, buf: &mut [u8]) -> usize

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

§Panics

Panics if the buffer is not large enough to hold Self::BYTES bytes.

§Returns

The number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

pub fn checked_copy_be_bytes_to(&self, buf: &mut [u8]) -> Option<usize>

Writes the big-endian representation of the Uint to the given buffer. The buffer must be large enough to hold Self::BYTES bytes.

§Returns

None, if the buffer is not large enough to hold Self::BYTES bytes, and does not modify the buffer.

Some with the number of bytes written to the buffer (always equal to Self::BYTES, but often useful to make explicit for encoders).

§

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

pub const LIMBS: usize

The size of this integer type in 64-bit limbs.

pub const MASK: u64

Bit mask for the last limb.

pub const BITS: usize = BITS

The size of this integer type in bits.

pub const ZERO: Uint<BITS, LIMBS>

The value zero. This is the only value that exists in all Uint types.

pub const MIN: Uint<BITS, LIMBS> = Self::ZERO

The smallest value that can be represented by this integer type. Synonym for Self::ZERO.

pub const MAX: Uint<BITS, LIMBS>

The largest value that can be represented by this integer type, $2^{\mathtt{BITS}} − 1$.

pub const fn as_limbs(&self) -> &[u64; LIMBS]

View the array of limbs.

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

Access the array of limbs.

§Safety

This function is unsafe because it allows setting a bit outside the bit size if the bit-size is not limb-aligned.

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

Convert to a array of limbs.

Limbs are least significant first.

pub const fn from_limbs(limbs: [u64; LIMBS]) -> Uint<BITS, LIMBS>

Construct a new integer from little-endian a array of limbs.

§Panics

Panics it LIMBS is not equal to nlimbs(BITS).

Panics if the value is too large for the bit-size of the Uint.

pub fn from_limbs_slice(slice: &[u64]) -> Uint<BITS, LIMBS>

Construct a new integer from little-endian a slice of limbs.

§Panics

Panics if the value is too large for the bit-size of the Uint.

pub fn checked_from_limbs_slice(slice: &[u64]) -> Option<Uint<BITS, LIMBS>>

Construct a new integer from little-endian a slice of limbs, or None if the value is too large for the Uint.

pub fn wrapping_from_limbs_slice(slice: &[u64]) -> Uint<BITS, LIMBS>

Construct a new Uint from a little-endian slice of limbs. Returns a potentially truncated value.

pub fn overflowing_from_limbs_slice(slice: &[u64]) -> (Uint<BITS, LIMBS>, bool)

Construct a new Uint from a little-endian slice of limbs. Returns a potentially truncated value and a boolean indicating whether the value was truncated.

pub fn saturating_from_limbs_slice(slice: &[u64]) -> Uint<BITS, LIMBS>

Construct a new Uint from a little-endian slice of limbs. Returns the maximum value if the value is too large for the Uint.

Trait Implementations

§

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

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the + operator.

§

fn add( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as Add<&Uint<BITS, LIMBS>>>::Output

Performs the + operation. Read more

§

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

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the + operator.

§

fn add(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as Add>::Output

Performs the + operation. Read more

§

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

§

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

Performs the += operation. Read more

§

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

§

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

Performs the += operation. Read more

§

impl<'a, const BITS: usize, const LIMBS: usize> Arbitrary<'a> for Uint<BITS, LIMBS>

§

fn arbitrary(u: &mut Unstructured<'a>) -> Result<Uint<BITS, LIMBS>, Error>

Generate an arbitrary value of Self from the given unstructured data. Read more

§

fn size_hint(_depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself. Read more

§

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data. Read more

§

fn try_size_hint( depth: usize, ) -> Result<(usize, Option<usize>), MaxRecursionReached>

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself. Read more

§

impl<const BITS: usize, const LIMBS: usize> Arbitrary for Uint<BITS, LIMBS>

§

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

§

type Strategy = Map<<[u64; LIMBS] as Arbitrary>::Strategy, fn(_: [u64; LIMBS]) -> Uint<BITS, LIMBS>>

The type of Strategy used to generate values of type Self.

§

fn arbitrary() -> <Uint<BITS, LIMBS> as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). Read more

§

fn arbitrary_with( _: <Uint<BITS, LIMBS> as Arbitrary>::Parameters, ) -> <Uint<BITS, LIMBS> as Arbitrary>::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args. Read more

§

impl<const BITS: usize, const LIMBS: usize> Binary for Uint<BITS, LIMBS>

§

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

Formats the value using the given formatter. Read more

§

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

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the & operator.

§

fn bitand( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as BitAnd<&Uint<BITS, LIMBS>>>::Output

Performs the & operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitAnd for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the & operator.

§

fn bitand(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as BitAnd>::Output

Performs the & operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitAndAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

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

Performs the &= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitAndAssign for Uint<BITS, LIMBS>

§

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

Performs the &= operation. Read more

§

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

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the | operator.

§

fn bitor( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as BitOr<&Uint<BITS, LIMBS>>>::Output

Performs the | operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitOr for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the | operator.

§

fn bitor(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as BitOr>::Output

Performs the | operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitOrAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

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

Performs the |= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitOrAssign for Uint<BITS, LIMBS>

§

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

Performs the |= operation. Read more

§

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

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ^ operator.

§

fn bitxor( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as BitXor<&Uint<BITS, LIMBS>>>::Output

Performs the ^ operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitXor for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ^ operator.

§

fn bitxor(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as BitXor>::Output

Performs the ^ operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitXorAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

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

Performs the ^= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> BitXorAssign for Uint<BITS, LIMBS>

§

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

Performs the ^= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Clone for Uint<BITS, LIMBS>

§

fn clone(&self) -> Uint<BITS, LIMBS>

Returns a copy of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

§

impl Compact for Uint<256, 4>

§

fn to_compact(&self, buf: &mut B) -> usize
where B: BufMut + AsMut<[u8]>,

Takes a buffer which can be written to. Ideally, it returns the length written to.

§

fn from_compact(buf: &[u8], len: usize) -> (Uint<256, 4>, &[u8])

Takes a buffer which can be read from. Returns the object and buf with its internal cursor advanced (eg..advance(len)). Read more

§

fn specialized_to_compact(&self, buf: &mut B) -> usize
where B: BufMut + AsMut<[u8]>,

“Optional”: If there’s no good reason to use it, don’t.

§

fn specialized_from_compact(buf: &[u8], len: usize) -> (Self, &[u8])

“Optional”: If there’s no good reason to use it, don’t.

§

impl<const BITS: usize, const LIMBS: usize> Debug for Uint<BITS, LIMBS>

§

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

Formats the value using the given formatter. Read more

§

impl<const BITS: usize, const LIMBS: usize> Decodable for Uint<BITS, LIMBS>

Allows a Uint to be deserialized from RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

§

fn decode(buf: &mut &[u8]) -> Result<Uint<BITS, LIMBS>, Error>

Decodes the blob into the appropriate type. buf must be advanced past the decoded object.

§

impl Decode for Uint<256, 4>

§

fn is_ssz_fixed_len() -> bool

Returns true if this object has a fixed-length. Read more

§

fn ssz_fixed_len() -> usize

The number of bytes this object occupies in the fixed-length portion of the SSZ bytes. Read more

§

fn from_ssz_bytes(bytes: &[u8]) -> Result<Uint<256, 4>, DecodeError>

Attempts to decode Self from bytes, returning a DecodeError on failure. Read more

§

impl<const BITS: usize, const LIMBS: usize> Default for Uint<BITS, LIMBS>

§

fn default() -> Uint<BITS, LIMBS>

Returns the “default value” for a type. Read more

§

impl<'de, const BITS: usize, const LIMBS: usize> Deserialize<'de> for Uint<BITS, LIMBS>

Deserialize human readable hex strings or byte arrays into Uint.

Hex strings can be upper/lower/mixed case, have an optional 0x prefix, and can be any length. They are interpreted big-endian.

§

fn deserialize<D>( deserializer: D, ) -> Result<Uint<BITS, LIMBS>, <D as Deserializer<'de>>::Error>
where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

§

impl<const BITS: usize, const LIMBS: usize> Display for Uint<BITS, LIMBS>

§

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

Formats the value using the given formatter. Read more

§

impl<const BITS: usize, const LIMBS: usize> Div<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the / operator.

§

fn div( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as Div<&Uint<BITS, LIMBS>>>::Output

Performs the / operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Div for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the / operator.

§

fn div(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as Div>::Output

Performs the / operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> DivAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

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

Performs the /= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> DivAssign for Uint<BITS, LIMBS>

§

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

Performs the /= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Encodable for Uint<BITS, LIMBS>

Allows a Uint to be serialized as RLP.

See https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/

§

fn length(&self) -> usize

Returns the length of the encoding of this type in bytes. Read more

§

fn encode(&self, out: &mut dyn BufMut)

Encodes the type into the out buffer.

§

impl Encode for Uint<256, 4>

§

fn is_ssz_fixed_len() -> bool

Returns true if this object has a fixed-length. Read more

§

fn ssz_fixed_len() -> usize

The number of bytes this object occupies in the fixed-length portion of the SSZ bytes. Read more

§

fn ssz_bytes_len(&self) -> usize

Returns the size (in bytes) when self is serialized. Read more

§

fn ssz_append(&self, buf: &mut Vec<u8>)

Append the encoding self to buf. Read more

§

fn as_ssz_bytes(&self) -> Vec<u8> ⓘ

Returns the full-form encoding of this object. Read more

§

impl<const BITS: usize, const LIMBS: usize> From<Bits<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

fn from(value: Bits<BITS, LIMBS>) -> Uint<BITS, LIMBS>

Converts to this type from the input type.

§

impl From<CompactU256> for Uint<256, 4>

§

fn from(value: CompactU256) -> Uint<256, 4>

Converts to this type from the input type.

§

impl From<FixedBytes<32>> for Uint<256, 4>

§

fn from(value: FixedBytes<32>) -> Uint<256, 4>

Converts a fixed byte array into a fixed-width unsigned integer by interpreting the bytes as big-endian.

§

impl From<Index> for Uint<256, 4>

§

fn from(idx: Index) -> Uint<256, 4>

Converts to this type from the input type.

§

impl From<Panic> for Uint<256, 4>

§

fn from(value: Panic) -> Uint<256, 4>

Converts to this type from the input type.

§

impl From<ParseUnits> for Uint<256, 4>

§

fn from(value: ParseUnits) -> Uint<256, 4>

Converts to this type from the input type.

§

impl<const BITS: usize, const LIMBS: usize> FromStr for Uint<BITS, LIMBS>

§

type Err = ParseError

The associated error which can be returned from parsing.

§

fn from_str( src: &str, ) -> Result<Uint<BITS, LIMBS>, <Uint<BITS, LIMBS> as FromStr>::Err>

Parses a string s to return a value of this type. Read more

§

impl<const BITS: usize, const LIMBS: usize> Hash for Uint<BITS, LIMBS>

§

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

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

§

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

Formats the value using the given formatter. Read more

§

impl<const BITS: usize, const LIMBS: usize> MaxEncodedLenAssoc for Uint<BITS, LIMBS>

§

const LEN: usize

The maximum length.

§

impl<const BITS: usize, const LIMBS: usize> Mul<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the * operator.

§

fn mul( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as Mul<&Uint<BITS, LIMBS>>>::Output

Performs the * operation. Read more

§

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

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the * operator.

§

fn mul(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as Mul>::Output

Performs the * operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> MulAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

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

Performs the *= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> MulAssign for Uint<BITS, LIMBS>

§

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

Performs the *= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Neg for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the - operator.

§

fn neg(self) -> <Uint<BITS, LIMBS> as Neg>::Output

Performs the unary - operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Not for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the ! operator.

§

fn not(self) -> <Uint<BITS, LIMBS> as Not>::Output

Performs the unary ! operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Octal for Uint<BITS, LIMBS>

§

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

Formats the value using the given formatter. Read more

§

impl<const BITS: usize, const LIMBS: usize> Ord for Uint<BITS, LIMBS>

§

fn cmp(&self, rhs: &Uint<BITS, LIMBS>) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more

1.21.0 · Source§

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

Compares and returns the minimum of two values. Read more

1.50.0 · Source§

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

Restrict a value to a certain interval. Read more

§

impl<const BITS: usize, const LIMBS: usize> PartialEq for Uint<BITS, LIMBS>

§

fn eq(&self, other: &Uint<BITS, LIMBS>) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

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 BITS: usize, const LIMBS: usize> PartialOrd for Uint<BITS, LIMBS>

§

fn partial_cmp(&self, other: &Uint<BITS, LIMBS>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · Source§

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

Tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · Source§

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

Tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · Source§

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

Tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · Source§

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

Tests greater than or equal to (for self and other) and is used by the >= operator. Read more

§

impl<'a, const BITS: usize, const LIMBS: usize> Product<&'a Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

fn product(iter: I) -> Uint<BITS, LIMBS>
where I: Iterator<Item = &'a Uint<BITS, LIMBS>>,

Takes an iterator and generates Self from the elements by multiplying the items.

§

impl<const BITS: usize, const LIMBS: usize> Product for Uint<BITS, LIMBS>

§

fn product(iter: I) -> Uint<BITS, LIMBS>
where I: Iterator<Item = Uint<BITS, LIMBS>>,

Takes an iterator and generates Self from the elements by multiplying the items.

§

impl<const BITS: usize, const LIMBS: usize> Rem<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the % operator.

§

fn rem( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as Rem<&Uint<BITS, LIMBS>>>::Output

Performs the % operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Rem for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the % operator.

§

fn rem(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as Rem>::Output

Performs the % operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> RemAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

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

Performs the %= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> RemAssign for Uint<BITS, LIMBS>

§

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

Performs the %= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Serialize for Uint<BITS, LIMBS>

Serialize a Uint value.

For human readable formats a 0x prefixed lower case hex string is used. For binary formats a byte array is used. Leading zeros are included.

§

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where S: Serializer,

Serialize this value into the given Serde serializer. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as Shl<&Uint<BITS, LIMBS>>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&i16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &i16) -> <Uint<BITS, LIMBS> as Shl<&i16>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&i32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &i32) -> <Uint<BITS, LIMBS> as Shl<&i32>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&i64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &i64) -> <Uint<BITS, LIMBS> as Shl<&i64>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&i8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &i8) -> <Uint<BITS, LIMBS> as Shl<&i8>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&isize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &isize) -> <Uint<BITS, LIMBS> as Shl<&isize>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&u16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &u16) -> <Uint<BITS, LIMBS> as Shl<&u16>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&u32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &u32) -> <Uint<BITS, LIMBS> as Shl<&u32>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&u64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &u64) -> <Uint<BITS, LIMBS> as Shl<&u64>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&u8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &u8) -> <Uint<BITS, LIMBS> as Shl<&u8>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<&usize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: &usize) -> <Uint<BITS, LIMBS> as Shl<&usize>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<i16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: i16) -> <Uint<BITS, LIMBS> as Shl<i16>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<i32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: i32) -> <Uint<BITS, LIMBS> as Shl<i32>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<i64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: i64) -> <Uint<BITS, LIMBS> as Shl<i64>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<i8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: i8) -> <Uint<BITS, LIMBS> as Shl<i8>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<isize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: isize) -> <Uint<BITS, LIMBS> as Shl<isize>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<u16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: u16) -> <Uint<BITS, LIMBS> as Shl<u16>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<u32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: u32) -> <Uint<BITS, LIMBS> as Shl<u32>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<u64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: u64) -> <Uint<BITS, LIMBS> as Shl<u64>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<u8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: u8) -> <Uint<BITS, LIMBS> as Shl<u8>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl<usize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: usize) -> <Uint<BITS, LIMBS> as Shl<usize>>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shl for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the << operator.

§

fn shl(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as Shl>::Output

Performs the << operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

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

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i16> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &i16)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i32> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &i32)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i64> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &i64)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&i8> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &i8)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&isize> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &isize)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u16> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &u16)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u32> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &u32)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u64> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &u64)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&u8> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &u8)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<&usize> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: &usize)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i16> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: i16)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i32> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i64> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: i64)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<i8> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: i8)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<isize> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: isize)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u16> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: u16)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u32> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u64> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: u64)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<u8> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: u8)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign<usize> for Uint<BITS, LIMBS>

§

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> ShlAssign for Uint<BITS, LIMBS>

§

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

Performs the <<= operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&Uint<BITS, LIMBS>> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr( self, rhs: &Uint<BITS, LIMBS>, ) -> <Uint<BITS, LIMBS> as Shr<&Uint<BITS, LIMBS>>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&i16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &i16) -> <Uint<BITS, LIMBS> as Shr<&i16>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&i32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &i32) -> <Uint<BITS, LIMBS> as Shr<&i32>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&i64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &i64) -> <Uint<BITS, LIMBS> as Shr<&i64>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&i8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &i8) -> <Uint<BITS, LIMBS> as Shr<&i8>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&isize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &isize) -> <Uint<BITS, LIMBS> as Shr<&isize>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&u16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &u16) -> <Uint<BITS, LIMBS> as Shr<&u16>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&u32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &u32) -> <Uint<BITS, LIMBS> as Shr<&u32>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&u64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &u64) -> <Uint<BITS, LIMBS> as Shr<&u64>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&u8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &u8) -> <Uint<BITS, LIMBS> as Shr<&u8>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<&usize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: &usize) -> <Uint<BITS, LIMBS> as Shr<&usize>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<i16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: i16) -> <Uint<BITS, LIMBS> as Shr<i16>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<i32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: i32) -> <Uint<BITS, LIMBS> as Shr<i32>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<i64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: i64) -> <Uint<BITS, LIMBS> as Shr<i64>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<i8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: i8) -> <Uint<BITS, LIMBS> as Shr<i8>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<isize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: isize) -> <Uint<BITS, LIMBS> as Shr<isize>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<u16> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: u16) -> <Uint<BITS, LIMBS> as Shr<u16>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<u32> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: u32) -> <Uint<BITS, LIMBS> as Shr<u32>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<u64> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: u64) -> <Uint<BITS, LIMBS> as Shr<u64>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<u8> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: u8) -> <Uint<BITS, LIMBS> as Shr<u8>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr<usize> for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: usize) -> <Uint<BITS, LIMBS> as Shr<usize>>::Output

Performs the >> operation. Read more

§

impl<const BITS: usize, const LIMBS: usize> Shr for Uint<BITS, LIMBS>

§

type Output = Uint<BITS, LIMBS>

The resulting type after applying the >> operator.

§

fn shr(self, rhs: Uint<BITS, LIMBS>) -> <Uint<BITS, LIMBS> as Shr>::Output

Performs the >> operation. Read more

§