Struct IMPLEMENTATION_SLOT 

pub struct IMPLEMENTATION_SLOT { /* private fields */ }

Methods from Deref<Target = SlotId>

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>

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

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.

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

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

Returns the dynamic length of this number in bits, ignoring leading zeros.

For the maximum length of the type, use Uint::BITS.

pub fn byte_len(&self) -> usize

Returns the dynamic length of this number in bytes, ignoring leading zeros.

For the maximum length of the type, use Uint::BYTES.

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 const BYTES: usize

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

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 fn as_le_bytes(&self) -> Cow<'_, [u8]>

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

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

Uses an optimized implementation on little-endian targets.

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

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>

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

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

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>

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

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

pub fn is_zero(&self) -> bool

Returns true if the value is zero.

pub fn const_is_zero(&self) -> bool

Returns true if the value is zero.

Note that this currently might perform worse than is_zero.

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

Returns true if self equals other.

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

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

pub const LIMBS: usize

pub const MASK: u64

pub const BITS: usize = BITS

pub const ZERO: Uint<BITS, LIMBS>

pub const ONE: Uint<BITS, LIMBS>

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

pub const MAX: Uint<BITS, LIMBS>

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

View the array of limbs.

Trait Implementations

impl Deref for IMPLEMENTATION_SLOT

type Target = Uint<256, 4>

The resulting type after dereferencing.

fn deref(&self) -> &SlotId

Dereferences the value.

impl LazyStatic for IMPLEMENTATION_SLOT