Struct BITS16MASK

struct BITS16MASK {
    __private_field: (),
}

Fields

__private_field: ()

Methods from Deref<Target = U256>

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.

Panics

Panics if the base is less than 2.

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 exceeds 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 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 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 is_zero(&self) -> bool

Returns true if the value is zero.

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

type Target = Uint<256, 4>

The resulting type after dereferencing.

fn deref(&self) -> &U256

Dereferences the value.

impl LazyStatic for BITS16MASK

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: 0 bytes