Struct Uint

Source

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

Expand description

The ring of numbers modulo $2^{\mathtt{BITS}}$.

Uint implements nearly all traits and methods from the std unsigned integer types, including most nightly only ones.

§Notable differences from `std` uint types.

The operators +, -, *, etc. using wrapping math by default. The std operators panic on overflow in debug, and are undefined in release, see reference.
The Uint::checked_shl, Uint::overflowing_shl, etc return overflow when non-zero bits are shifted out. In std they return overflow when the shift amount is greater than the bit size.
Some methods like u64::div_euclid and u64::rem_euclid are left out because they are meaningless or redundant for unsigned integers. Std has them for compatibility with their signed integers.
Many functions that are const in std are not in Uint.
Uint::to_le_bytes and Uint::to_be_bytes require the output size to be provided as a const-generic argument. They will runtime panic if the provided size is incorrect.
Uint::widening_mul takes as argument an Uint of arbitrary size and returns a result that is sized to fit the product without overflow (i.e. the sum of the bit sizes of self and the argument). The std version requires same-sized arguments and returns a pair of lower and higher bits.

Implementations§

Source §

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

Source

pub fn abs_diff(self, other: Self) -> Self

Computes the absolute difference between self and other.

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

Source

pub const fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occurred.

Source

pub const fn checked_neg(self) -> Option<Self>

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

Source

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

Source

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

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

Source

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

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

Source

pub const fn wrapping_neg(self) -> Self

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

Source

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

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

Source §

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

Source

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.

Source

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

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.

Use to_base_be_2 to extract the maximum number of digits at once more efficiently.

§Panics

Panics if the base is less than 2.

§Examples

let n = ruint::aliases::U64::from(1234);
assert_eq!(n.to_base_be(10).collect::<Vec<_>>(), [1, 2, 3, 4]);
assert_eq!(n.to_base_be(1000000).collect::<Vec<_>>(), [1234]);

// `to_base_be_2` always returns digits maximally packed into `u64`s.
assert_eq!(n.to_base_be_2(10).collect::<Vec<_>>(), [1234]);
assert_eq!(n.to_base_be_2(1000000).collect::<Vec<_>>(), [1234]);

Source

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

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

Always returns digits maximally packed into u64s. Unlike to_base_be, this method:

never heap-allocates memory, so it’s always faster
always returns digits maximally packed into u64s, so passing the constant base like 2, 8, instead of the highest power that fits in u64 is not needed

§Panics

Panics if the base is less than 2.

§Examples

See to_base_be.

Source

pub fn from_base_le(base: u64, digits: I) -> Result<Self, 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.

Source

pub fn from_base_be<I: IntoIterator<Item = u64>>( base: u64, digits: I, ) -> Result<Self, BaseConvertError>

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.

Source §

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

Source

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.

Source

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

Sets a specific bit to a value.

Source

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

Source

pub const 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));
assert_eq!(x.checked_byte(7), Some(0x00));
// Out of range
assert_eq!(x.checked_byte(8), None);

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.

Source

pub const fn checked_shl(self, rhs: usize) -> Option<Self>

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

Source

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

Source

pub const fn overflowing_shr(self, rhs: usize) -> (Self, 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).

Source

pub const fn wrapping_shr(self, rhs: usize) -> Self

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

Source

pub const fn arithmetic_shr(self, rhs: usize) -> Self

Arithmetic shift right by rhs bits.

Source

pub const fn rotate_left(self, rhs: usize) -> Self

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

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

Only available on litte-endian targets.

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.

Source

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

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.

Source

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

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

Source

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.

Source

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

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.

Source

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

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

Source

pub const fn from_be_bytes<const BYTES: usize>(bytes: [u8; BYTES]) -> Self

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.

Source

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

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

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

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

The slice is interpreted as a little endian number, and must be at most Self::BYTES long.

§Panics

Panics if the value is larger than fits the Uint.

Source

pub const fn try_from_le_slice(bytes: &[u8]) -> Option<Self>

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

The slice is interpreted as a little endian number, and must be at most Self::BYTES long.

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

Source

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

Source

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

Source

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 const fn const_is_zero(&self) -> bool

Returns true if the value is zero.

Note that this currently might perform worse than is_zero.

Source

pub const fn const_eq(&self, other: &Self) -> bool

Returns true if self equals other.

Note that this currently might perform worse than the derived PartialEq (== operator).

Source §

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

Source

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

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

Source

pub fn from<T>(value: T) -> Self
where Self: 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);

Source

pub fn saturating_from<T>(value: T) -> Self
where Self: 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);

Source

pub fn wrapping_from<T>(value: T) -> Self
where Self: 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);

Source

pub fn to<T>(&self) -> T
where Self: 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);

Source

pub fn wrapping_to<T>(&self) -> T
where Self: 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);

Source

pub fn saturating_to<T>(&self) -> T
where Self: 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);

Source §

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

Source

pub fn gcd(self, other: Self) -> Self

Compute the greatest common divisor of two Uints.

§Examples

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

Source

pub fn lcm(self, other: Self) -> Option<Self>

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

Source

pub fn gcd_extended(self, other: Self) -> (Self, Self, Self, 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.

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

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

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 mul_mod(self, rhs: Self, modulus: Self) -> Self

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.

Source

pub fn pow_mod(self, exp: Self, modulus: Self) -> Self

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

Returns zero if the modulus is zero.

Source

pub fn inv_mod(self, modulus: Self) -> Option<Self>

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

Returns None if the inverse does not exist.

Source

pub fn mul_redc(self, other: Self, modulus: Self, inv: u64) -> Self

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.

Source

pub fn square_redc(self, modulus: Self, inv: u64) -> Self

Montgomery squaring.

See Self::mul_redc.

Source §

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

pub fn overflowing_pow(self, exp: Self) -> (Self, 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));

Source

pub fn pow(self, exp: Self) -> Self

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

Source

pub fn saturating_pow(self, exp: Self) -> Self

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

Source

pub fn wrapping_pow(self, exp: Self) -> Self

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

Source

pub fn approx_pow2(exp: f64) -> Option<Self>

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

Source §

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

Source

pub fn root(self, degree: usize) -> Self

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

Source §

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

Source

pub const fn is_power_of_two(self) -> bool

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

Source

pub fn next_power_of_two(self) -> Self

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

§Panics

Panics if the value overlfows.

Source

pub fn checked_next_power_of_two(self) -> Option<Self>

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

Source §

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

Source

pub fn next_multiple_of(self, rhs: Self) -> Self

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.

Source

pub fn checked_next_multiple_of(self, rhs: Self) -> Option<Self>

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));
}

Source §

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

Source

pub fn from_str_radix(src: &str, radix: u64) -> Result<Self, 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.

Source §

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

Source

pub const LIMBS: usize

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

Source

pub const MASK: u64

Bit mask for the last limb.

Source

pub const BITS: usize = BITS

The size of this integer type in bits.

Source

pub const ZERO: Self

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

Source

pub const ONE: Self

The value one. This is useful to have as a constant for use in const fn.

Zero if BITS is zero.

Source

pub const MIN: Self = Self::ZERO

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

Source

pub const MAX: Self

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

Source

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

View the array of limbs.

Source

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.

Source

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

Convert to a array of limbs.

Limbs are least significant first.

pub fn checked_from_limbs_slice(slice: &[u64]) -> Option<Self>

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

Source

pub fn wrapping_from_limbs_slice(slice: &[u64]) -> Self

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

Source

pub fn overflowing_from_limbs_slice(slice: &[u64]) -> (Self, 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.

Source

pub fn saturating_from_limbs_slice(slice: &[u64]) -> Self

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

Performs copy-assignment from source. Read more

Source §

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

Source §

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

Formats the value using the given formatter. Read more

Source §

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/

Source §

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

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

Source §

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

Source §

fn default() -> Self

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

Source §

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.

Allows a Uint to be serialized as RLP.

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

Source §

fn length(&self) -> usize

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

Source §

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

Encodes the type into the out buffer.

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

Source §

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

Feeds this value into the given Hasher. Read more

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

Source §

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

Source §

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

Source §

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

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Source §

Struct UintCopy item path

§Notable differences from std uint types.

Implementations§

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

pub fn abs_diff(self, other: Self) -> Self

pub const fn checked_add(self, rhs: Self) -> Option<Self>

pub const fn checked_neg(self) -> Option<Self>

pub const fn checked_sub(self, rhs: Self) -> Option<Self>

pub const fn overflowing_add(self, rhs: Self) -> (Self, bool)

pub const fn overflowing_neg(self) -> (Self, bool)

pub const fn overflowing_sub(self, rhs: Self) -> (Self, bool)

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

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

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

pub const fn wrapping_neg(self) -> Self

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

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

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

§Panics

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

§Panics

§Examples

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

§Panics

§Examples

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

§Errors

pub fn from_base_be<I: IntoIterator<Item = u64>>( base: u64, digits: I, ) -> Result<Self, BaseConvertError>

§Errors

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

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

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

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

§Panics

§Examples

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

§Examples

pub fn reverse_bits(self) -> Self

pub const fn not(self) -> Self

pub const fn leading_zeros(&self) -> usize

pub const fn leading_ones(&self) -> usize

pub fn trailing_zeros(&self) -> usize

pub fn trailing_ones(&self) -> usize

pub const fn count_ones(&self) -> usize

pub const fn count_zeros(&self) -> usize

pub const fn bit_len(&self) -> usize

pub const fn byte_len(&self) -> usize

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

pub const fn checked_shl(self, rhs: usize) -> Option<Self>

pub const fn saturating_shl(self, rhs: usize) -> Self

pub const fn overflowing_shl(self, rhs: usize) -> (Self, bool)

pub const fn wrapping_shl(self, rhs: usize) -> Self

pub const fn checked_shr(self, rhs: usize) -> Option<Self>

pub const fn overflowing_shr(self, rhs: usize) -> (Self, bool)

pub const fn wrapping_shr(self, rhs: usize) -> Self

pub const fn arithmetic_shr(self, rhs: usize) -> Self

pub const fn rotate_left(self, rhs: usize) -> Self

pub const fn rotate_right(self, rhs: usize) -> Self

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

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

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

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

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

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

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

pub const BYTES: usize

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

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

§Safety

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

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

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

§Panics

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

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

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

§Panics

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

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

pub const fn from_be_bytes<const BYTES: usize>(bytes: [u8; BYTES]) -> Self

Struct Uint

§Notable differences from `std` uint types.

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

pub fn from<T>(value: T) -> Self
where Self: UintTryFrom<T>,

pub fn saturating_from<T>(value: T) -> Self
where Self: UintTryFrom<T>,

pub fn wrapping_from<T>(value: T) -> Self
where Self: UintTryFrom<T>,

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

pub fn wrapping_to<T>(&self) -> T
where Self: UintTryTo<T>,

pub fn saturating_to<T>(&self) -> T
where Self: UintTryTo<T>,