Struct UInt

pub struct UInt<T, const BITS: usize> { /* private fields */ }

Implementations

impl<T: Copy, const BITS: usize> UInt<T, BITS>

pub const BITS: usize = BITS

pub const fn value(self) -> T

Returns the type as a fundamental data type

pub const unsafe fn new_unchecked(value: T) -> Self

Initializes a new value without checking the bounds

Safety

Must only be called with a value less than or equal to Self::MAX value.

impl<T, const BITS: usize> UInt<T, BITS>

where Self: Number, T: Copy,

pub const MASK: T

impl<const BITS: usize> UInt<u8, BITS>

pub const fn new(value: u8) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u8(value: u8) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u16(value: u16) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u32(value: u32) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u64(value: u64) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u128(value: u128) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn try_new(value: u8) -> Result<Self, TryNewError>

Creates an instance or an error if the given value is outside of the valid range

pub const fn extract(value: u8, start_bit: usize) -> Self

👎Deprecated: Use one of the specific functions like extract_u32

pub const fn extract_u8(value: u8, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient. panics if start_bit+ doesn’t fit within an u8, e.g. u5::extract_u8(8, 4);

pub const fn extract_u16(value: u16, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u16, e.g. u15::extract_u16(8, 2);

pub const fn extract_u32(value: u32, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u32, e.g. u30::extract_u32(8, 4);

pub const fn extract_u64(value: u64, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u64, e.g. u60::extract_u64(8, 5);

pub const fn extract_u128(value: u128, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u128, e.g. u120::extract_u64(8, 9);

pub const fn widen<const BITS_RESULT: usize>(self) -> UInt<u8, BITS_RESULT>

Returns a UInt with a wider bit depth but with the same base data type

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub const fn reverse_bits(self) -> Self

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 const fn count_ones(self) -> u32

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

pub const fn count_zeros(self) -> u32

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

pub const fn leading_ones(self) -> u32

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

pub const fn leading_zeros(self) -> u32

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

pub const fn trailing_ones(self) -> u32

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

pub const fn trailing_zeros(self) -> u32

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

pub const fn rotate_left(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer. Please note this isn’t the same operation as the << shifting operator!

pub const fn rotate_right(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer. Please note this isn’t the same operation as the >> shifting operator!

impl<const BITS: usize> UInt<u16, BITS>

pub const fn new(value: u16) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u8(value: u8) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u16(value: u16) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u32(value: u32) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u64(value: u64) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u128(value: u128) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn try_new(value: u16) -> Result<Self, TryNewError>

Creates an instance or an error if the given value is outside of the valid range

pub const fn extract(value: u16, start_bit: usize) -> Self

👎Deprecated: Use one of the specific functions like extract_u32

pub const fn extract_u8(value: u8, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient. panics if start_bit+ doesn’t fit within an u8, e.g. u5::extract_u8(8, 4);

pub const fn extract_u16(value: u16, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u16, e.g. u15::extract_u16(8, 2);

pub const fn extract_u32(value: u32, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u32, e.g. u30::extract_u32(8, 4);

pub const fn extract_u64(value: u64, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u64, e.g. u60::extract_u64(8, 5);

pub const fn extract_u128(value: u128, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u128, e.g. u120::extract_u64(8, 9);

pub const fn widen<const BITS_RESULT: usize>(self) -> UInt<u16, BITS_RESULT>

Returns a UInt with a wider bit depth but with the same base data type

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub const fn reverse_bits(self) -> Self

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 const fn count_ones(self) -> u32

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

pub const fn count_zeros(self) -> u32

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

pub const fn leading_ones(self) -> u32

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

pub const fn leading_zeros(self) -> u32

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

pub const fn trailing_ones(self) -> u32

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

pub const fn trailing_zeros(self) -> u32

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

pub const fn rotate_left(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer. Please note this isn’t the same operation as the << shifting operator!

pub const fn rotate_right(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer. Please note this isn’t the same operation as the >> shifting operator!

impl<const BITS: usize> UInt<u32, BITS>

pub const fn new(value: u32) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u8(value: u8) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u16(value: u16) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u32(value: u32) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u64(value: u64) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u128(value: u128) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn try_new(value: u32) -> Result<Self, TryNewError>

Creates an instance or an error if the given value is outside of the valid range

pub const fn extract(value: u32, start_bit: usize) -> Self

👎Deprecated: Use one of the specific functions like extract_u32

pub const fn extract_u8(value: u8, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient. panics if start_bit+ doesn’t fit within an u8, e.g. u5::extract_u8(8, 4);

pub const fn extract_u16(value: u16, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u16, e.g. u15::extract_u16(8, 2);

pub const fn extract_u32(value: u32, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u32, e.g. u30::extract_u32(8, 4);

pub const fn extract_u64(value: u64, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u64, e.g. u60::extract_u64(8, 5);

pub const fn extract_u128(value: u128, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u128, e.g. u120::extract_u64(8, 9);

pub const fn widen<const BITS_RESULT: usize>(self) -> UInt<u32, BITS_RESULT>

Returns a UInt with a wider bit depth but with the same base data type

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub const fn reverse_bits(self) -> Self

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 const fn count_ones(self) -> u32

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

pub const fn count_zeros(self) -> u32

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

pub const fn leading_ones(self) -> u32

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

pub const fn leading_zeros(self) -> u32

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

pub const fn trailing_ones(self) -> u32

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

pub const fn trailing_zeros(self) -> u32

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

pub const fn rotate_left(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer. Please note this isn’t the same operation as the << shifting operator!

pub const fn rotate_right(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer. Please note this isn’t the same operation as the >> shifting operator!

impl<const BITS: usize> UInt<u64, BITS>

pub const fn new(value: u64) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u8(value: u8) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u16(value: u16) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u32(value: u32) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u64(value: u64) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u128(value: u128) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn try_new(value: u64) -> Result<Self, TryNewError>

Creates an instance or an error if the given value is outside of the valid range

pub const fn extract(value: u64, start_bit: usize) -> Self

👎Deprecated: Use one of the specific functions like extract_u32

pub const fn extract_u8(value: u8, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient. panics if start_bit+ doesn’t fit within an u8, e.g. u5::extract_u8(8, 4);

pub const fn extract_u16(value: u16, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u16, e.g. u15::extract_u16(8, 2);

pub const fn extract_u32(value: u32, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u32, e.g. u30::extract_u32(8, 4);

pub const fn extract_u64(value: u64, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u64, e.g. u60::extract_u64(8, 5);

pub const fn extract_u128(value: u128, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u128, e.g. u120::extract_u64(8, 9);

pub const fn widen<const BITS_RESULT: usize>(self) -> UInt<u64, BITS_RESULT>

Returns a UInt with a wider bit depth but with the same base data type

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub const fn reverse_bits(self) -> Self

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 const fn count_ones(self) -> u32

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

pub const fn count_zeros(self) -> u32

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

pub const fn leading_ones(self) -> u32

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

pub const fn leading_zeros(self) -> u32

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

pub const fn trailing_ones(self) -> u32

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

pub const fn trailing_zeros(self) -> u32

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

pub const fn rotate_left(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer. Please note this isn’t the same operation as the << shifting operator!

pub const fn rotate_right(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer. Please note this isn’t the same operation as the >> shifting operator!

impl<const BITS: usize> UInt<u128, BITS>

pub const fn new(value: u128) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u8(value: u8) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u16(value: u16) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u32(value: u32) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u64(value: u64) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn from_u128(value: u128) -> Self

Creates an instance. Panics if the given value is outside of the valid range

pub const fn try_new(value: u128) -> Result<Self, TryNewError>

Creates an instance or an error if the given value is outside of the valid range

pub const fn extract(value: u128, start_bit: usize) -> Self

👎Deprecated: Use one of the specific functions like extract_u32

pub const fn extract_u8(value: u8, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient. panics if start_bit+ doesn’t fit within an u8, e.g. u5::extract_u8(8, 4);

pub const fn extract_u16(value: u16, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u16, e.g. u15::extract_u16(8, 2);

pub const fn extract_u32(value: u32, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u32, e.g. u30::extract_u32(8, 4);

pub const fn extract_u64(value: u64, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u64, e.g. u60::extract_u64(8, 5);

pub const fn extract_u128(value: u128, start_bit: usize) -> Self

Extracts bits from a given value. The extract is equivalent to: new((value >> start_bit) & MASK) Unlike new, extract doesn’t perform range-checking so it is slightly more efficient panics if start_bit+ doesn’t fit within a u128, e.g. u120::extract_u64(8, 9);

pub const fn widen<const BITS_RESULT: usize>(self) -> UInt<u128, BITS_RESULT>

Returns a UInt with a wider bit depth but with the same base data type

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub const fn reverse_bits(self) -> Self

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 const fn count_ones(self) -> u32

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

pub const fn count_zeros(self) -> u32

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

pub const fn leading_ones(self) -> u32

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

pub const fn leading_zeros(self) -> u32

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

pub const fn trailing_ones(self) -> u32

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

pub const fn trailing_zeros(self) -> u32

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

pub const fn rotate_left(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, wrapping the truncated bits to the end of the resulting integer. Please note this isn’t the same operation as the << shifting operator!

pub const fn rotate_right(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, wrapping the truncated bits to the beginning of the resulting integer. Please note this isn’t the same operation as the >> shifting operator!

impl UInt<u32, 24>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 3]) -> Self

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

pub const fn from_be_bytes(from: [u8; 3]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 3]

pub const fn from_ne_bytes(bytes: [u8; 3]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u64, 24>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 3]) -> Self

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

pub const fn from_be_bytes(from: [u8; 3]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 3]

pub const fn from_ne_bytes(bytes: [u8; 3]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 24>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 3]) -> Self

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

pub const fn from_be_bytes(from: [u8; 3]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 3]

pub const fn from_ne_bytes(bytes: [u8; 3]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u64, 40>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 5]) -> Self

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

pub const fn from_be_bytes(from: [u8; 5]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 5]

pub const fn from_ne_bytes(bytes: [u8; 5]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 40>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 5]) -> Self

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

pub const fn from_be_bytes(from: [u8; 5]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 5]

pub const fn from_ne_bytes(bytes: [u8; 5]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u64, 48>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 6]) -> Self

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

pub const fn from_be_bytes(from: [u8; 6]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 6]

pub const fn from_ne_bytes(bytes: [u8; 6]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 48>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 6]) -> Self

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

pub const fn from_be_bytes(from: [u8; 6]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 6]

pub const fn from_ne_bytes(bytes: [u8; 6]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u64, 56>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 7]) -> Self

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

pub const fn from_be_bytes(from: [u8; 7]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 7]

pub const fn from_ne_bytes(bytes: [u8; 7]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 56>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 7]) -> Self

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

pub const fn from_be_bytes(from: [u8; 7]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 7]

pub const fn from_ne_bytes(bytes: [u8; 7]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 72>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 9]) -> Self

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

pub const fn from_be_bytes(from: [u8; 9]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 9]

pub const fn from_ne_bytes(bytes: [u8; 9]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 80>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 10]) -> Self

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

pub const fn from_be_bytes(from: [u8; 10]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 10]

pub const fn from_ne_bytes(bytes: [u8; 10]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 88>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 11]) -> Self

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

pub const fn from_be_bytes(from: [u8; 11]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 11]

pub const fn from_ne_bytes(bytes: [u8; 11]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 96>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 12]) -> Self

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

pub const fn from_be_bytes(from: [u8; 12]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 12]

pub const fn from_ne_bytes(bytes: [u8; 12]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 104>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 13]) -> Self

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

pub const fn from_be_bytes(from: [u8; 13]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 13]

pub const fn from_ne_bytes(bytes: [u8; 13]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 112>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 14]) -> Self

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

pub const fn from_be_bytes(from: [u8; 14]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 14]

pub const fn from_ne_bytes(bytes: [u8; 14]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

impl UInt<u128, 120>

pub const fn swap_bytes(&self) -> Self

Reverses the byte order of the integer.

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

pub const fn from_le_bytes(from: [u8; 15]) -> Self

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

pub const fn from_be_bytes(from: [u8; 15]) -> Self

pub const fn to_ne_bytes(&self) -> [u8; 15]

pub const fn from_ne_bytes(bytes: [u8; 15]) -> Self

pub const fn to_le(self) -> Self

pub const fn to_be(self) -> Self

pub const fn from_le(value: Self) -> Self

pub const fn from_be(value: Self) -> Self

Trait Implementations

impl<T, const BITS: usize> Add for UInt<T, BITS>

where Self: Number, T: PartialEq + Copy + BitAnd<T, Output = T> + Not<Output = T> + Add<T, Output = T> + Sub<T, Output = T> + From<u8>,

type Output = UInt<T, BITS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const BITS: usize> AddAssign for UInt<T, BITS>

where Self: Number, T: PartialEq + Eq + Not<Output = T> + Copy + AddAssign<T> + BitAnd<T, Output = T> + BitAndAssign<T> + From<u8>,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<T, const BITS: usize> Binary for UInt<T, BITS>

where T: Binary,

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

Formats the value using the given formatter.

impl<T, const BITS: usize> BitAnd for UInt<T, BITS>

where Self: Number, T: Copy + BitAnd<T, Output = T> + Sub<T, Output = T> + Shl<usize, Output = T> + Shr<usize, Output = T> + From<u8>,

type Output = UInt<T, BITS>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T, const BITS: usize> BitAndAssign for UInt<T, BITS>

where T: Copy + BitAndAssign<T> + Sub<T, Output = T> + Shl<usize, Output = T> + From<u8>,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl<T, const BITS: usize> BitOr for UInt<T, BITS>

where T: Copy + BitOr<T, Output = T> + Sub<T, Output = T> + Shl<usize, Output = T> + From<u8>,

type Output = UInt<T, BITS>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T, const BITS: usize> BitOrAssign for UInt<T, BITS>

where T: Copy + BitOrAssign<T> + Sub<T, Output = T> + Shl<usize, Output = T> + From<u8>,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl<T, const BITS: usize> BitXor for UInt<T, BITS>

where T: Copy + BitXor<T, Output = T> + Sub<T, Output = T> + Shl<usize, Output = T> + From<u8>,

type Output = UInt<T, BITS>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T, const BITS: usize> BitXorAssign for UInt<T, BITS>

where T: Copy + BitXorAssign<T> + Sub<T, Output = T> + Shl<usize, Output = T> + From<u8>,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<T: Clone, const BITS: usize> Clone for UInt<T, BITS>

fn clone(&self) -> UInt<T, BITS>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, const BITS: usize> Debug for UInt<T, BITS>

where T: Debug,

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

Formats the value using the given formatter.

impl<T: Default, const BITS: usize> Default for UInt<T, BITS>

fn default() -> UInt<T, BITS>

Returns the “default value” for a type.

impl<T, const BITS: usize> Display for UInt<T, BITS>

where T: Display,

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

Formats the value using the given formatter.

impl<T, const BITS: usize> Div for UInt<T, BITS>

where Self: Number, T: PartialEq + Div<T, Output = T>,

type Output = UInt<T, BITS>

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T, const BITS: usize> DivAssign for UInt<T, BITS>

where Self: Number, T: PartialEq + DivAssign<T>,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const BITS: usize> From<UInt<u128, BITS>> for u128

fn from(from: UInt<u128, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u128, BITS>> for u16

fn from(from: UInt<u128, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u128, BITS>> for u32

fn from(from: UInt<u128, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u128, BITS>> for u64

fn from(from: UInt<u128, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u128, BITS>> for u8

fn from(from: UInt<u128, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u128, BITS_FROM>> for UInt<u16, BITS>

fn from(item: UInt<u128, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u128, BITS_FROM>> for UInt<u32, BITS>

fn from(item: UInt<u128, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u128, BITS_FROM>> for UInt<u64, BITS>

fn from(item: UInt<u128, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u128, BITS_FROM>> for UInt<u8, BITS>

fn from(item: UInt<u128, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u16, BITS>> for u128

fn from(from: UInt<u16, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u16, BITS>> for u16

fn from(from: UInt<u16, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u16, BITS>> for u32

fn from(from: UInt<u16, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u16, BITS>> for u64

fn from(from: UInt<u16, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u16, BITS>> for u8

fn from(from: UInt<u16, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u16, BITS_FROM>> for UInt<u128, BITS>

fn from(item: UInt<u16, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u16, BITS_FROM>> for UInt<u32, BITS>

fn from(item: UInt<u16, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u16, BITS_FROM>> for UInt<u64, BITS>

fn from(item: UInt<u16, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u16, BITS_FROM>> for UInt<u8, BITS>

fn from(item: UInt<u16, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u32, BITS>> for u128

fn from(from: UInt<u32, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u32, BITS>> for u16

fn from(from: UInt<u32, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u32, BITS>> for u32

fn from(from: UInt<u32, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u32, BITS>> for u64

fn from(from: UInt<u32, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u32, BITS>> for u8

fn from(from: UInt<u32, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u32, BITS_FROM>> for UInt<u128, BITS>

fn from(item: UInt<u32, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u32, BITS_FROM>> for UInt<u16, BITS>

fn from(item: UInt<u32, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u32, BITS_FROM>> for UInt<u64, BITS>

fn from(item: UInt<u32, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u32, BITS_FROM>> for UInt<u8, BITS>

fn from(item: UInt<u32, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u64, BITS>> for u128

fn from(from: UInt<u64, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u64, BITS>> for u16

fn from(from: UInt<u64, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u64, BITS>> for u32

fn from(from: UInt<u64, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u64, BITS>> for u64

fn from(from: UInt<u64, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u64, BITS>> for u8

fn from(from: UInt<u64, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u64, BITS_FROM>> for UInt<u128, BITS>

fn from(item: UInt<u64, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u64, BITS_FROM>> for UInt<u16, BITS>

fn from(item: UInt<u64, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u64, BITS_FROM>> for UInt<u32, BITS>

fn from(item: UInt<u64, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u64, BITS_FROM>> for UInt<u8, BITS>

fn from(item: UInt<u64, BITS_FROM>) -> Self

Converts to this type from the input type.

impl From<UInt<u8, 1>> for bool

fn from(value: u1) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u8, BITS>> for u128

fn from(from: UInt<u8, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u8, BITS>> for u16

fn from(from: UInt<u8, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u8, BITS>> for u32

fn from(from: UInt<u8, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u8, BITS>> for u64

fn from(from: UInt<u8, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<UInt<u8, BITS>> for u8

fn from(from: UInt<u8, BITS>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u8, BITS_FROM>> for UInt<u128, BITS>

fn from(item: UInt<u8, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u8, BITS_FROM>> for UInt<u16, BITS>

fn from(item: UInt<u8, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u8, BITS_FROM>> for UInt<u32, BITS>

fn from(item: UInt<u8, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize, const BITS_FROM: usize> From<UInt<u8, BITS_FROM>> for UInt<u64, BITS>

fn from(item: UInt<u8, BITS_FROM>) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u128> for UInt<u128, BITS>

fn from(from: u128) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u128> for UInt<u16, BITS>

fn from(from: u128) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u128> for UInt<u32, BITS>

fn from(from: u128) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u128> for UInt<u64, BITS>

fn from(from: u128) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u128> for UInt<u8, BITS>

fn from(from: u128) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u16> for UInt<u128, BITS>

fn from(from: u16) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u16> for UInt<u16, BITS>

fn from(from: u16) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u16> for UInt<u32, BITS>

fn from(from: u16) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u16> for UInt<u64, BITS>

fn from(from: u16) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u16> for UInt<u8, BITS>

fn from(from: u16) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u32> for UInt<u128, BITS>

fn from(from: u32) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u32> for UInt<u16, BITS>

fn from(from: u32) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u32> for UInt<u32, BITS>

fn from(from: u32) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u32> for UInt<u64, BITS>

fn from(from: u32) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u32> for UInt<u8, BITS>

fn from(from: u32) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u64> for UInt<u128, BITS>

fn from(from: u64) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u64> for UInt<u16, BITS>

fn from(from: u64) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u64> for UInt<u32, BITS>

fn from(from: u64) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u64> for UInt<u64, BITS>

fn from(from: u64) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u64> for UInt<u8, BITS>

fn from(from: u64) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u8> for UInt<u128, BITS>

fn from(from: u8) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u8> for UInt<u16, BITS>

fn from(from: u8) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u8> for UInt<u32, BITS>

fn from(from: u8) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u8> for UInt<u64, BITS>

fn from(from: u8) -> Self

Converts to this type from the input type.

impl<const BITS: usize> From<u8> for UInt<u8, BITS>

fn from(from: u8) -> Self

Converts to this type from the input type.

impl<T, const BITS: usize> Hash for UInt<T, BITS>

where T: Hash,

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const BITS: usize> LowerHex for UInt<T, BITS>

where T: LowerHex,

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

Formats the value using the given formatter.

impl<T, const BITS: usize> Mul for UInt<T, BITS>

where Self: Number, T: PartialEq + Copy + BitAnd<T, Output = T> + Not<Output = T> + Mul<T, Output = T> + From<u8>,

type Output = UInt<T, BITS>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T, const BITS: usize> MulAssign for UInt<T, BITS>

where Self: Number, T: PartialEq + Eq + Not<Output = T> + Copy + MulAssign<T> + BitAnd<T, Output = T> + BitAndAssign<T> + From<u8>,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<T, const BITS: usize> Not for UInt<T, BITS>

where Self: Number, T: Copy + BitAnd<T, Output = T> + BitXor<T, Output = T> + Sub<T, Output = T> + Shl<usize, Output = T> + Shr<usize, Output = T> + From<u8>,

type Output = UInt<T, BITS>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const BITS: usize> Number for UInt<u128, BITS>

const BITS: usize = BITS

Number of bits that can fit in this type

const MIN: Self

Minimum value that can be represented by this type

const MAX: Self

Maximum value that can be represented by this type

type UnderlyingType = u128

fn try_new(value: Self::UnderlyingType) -> Result<Self, TryNewError>

Creates a number from the given value, return None if the value is too large

fn new(value: u128) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when creating a value from a literal.

fn from_<T: Number>(value: T) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when the value is convertable to T. Use Self::new for literals.

fn masked_new<T: Number>(value: T) -> Self

Creates an instance from the given value. Unlike the various new... functions, this will never fail as the value is masked to the result size.

fn as_u8(&self) -> u8

fn as_u16(&self) -> u16

fn as_u32(&self) -> u32

fn as_u64(&self) -> u64

fn as_u128(&self) -> u128

fn as_usize(&self) -> usize

fn value(self) -> u128

fn as_<T: Number>(self) -> T

impl<const BITS: usize> Number for UInt<u16, BITS>

const BITS: usize = BITS

Number of bits that can fit in this type

const MIN: Self

Minimum value that can be represented by this type

const MAX: Self

Maximum value that can be represented by this type

type UnderlyingType = u16

fn try_new(value: Self::UnderlyingType) -> Result<Self, TryNewError>

Creates a number from the given value, return None if the value is too large

fn new(value: u16) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when creating a value from a literal.

fn from_<T: Number>(value: T) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when the value is convertable to T. Use Self::new for literals.

fn masked_new<T: Number>(value: T) -> Self

Creates an instance from the given value. Unlike the various new... functions, this will never fail as the value is masked to the result size.

fn as_u8(&self) -> u8

fn as_u16(&self) -> u16

fn as_u32(&self) -> u32

fn as_u64(&self) -> u64

fn as_u128(&self) -> u128

fn as_usize(&self) -> usize

fn value(self) -> u16

fn as_<T: Number>(self) -> T

impl<const BITS: usize> Number for UInt<u32, BITS>

const BITS: usize = BITS

Number of bits that can fit in this type

const MIN: Self

Minimum value that can be represented by this type

const MAX: Self

Maximum value that can be represented by this type

type UnderlyingType = u32

fn try_new(value: Self::UnderlyingType) -> Result<Self, TryNewError>

Creates a number from the given value, return None if the value is too large

fn new(value: u32) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when creating a value from a literal.

fn from_<T: Number>(value: T) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when the value is convertable to T. Use Self::new for literals.

fn masked_new<T: Number>(value: T) -> Self

Creates an instance from the given value. Unlike the various new... functions, this will never fail as the value is masked to the result size.

fn as_u8(&self) -> u8

fn as_u16(&self) -> u16

fn as_u32(&self) -> u32

fn as_u64(&self) -> u64

fn as_u128(&self) -> u128

fn as_usize(&self) -> usize

fn value(self) -> u32

fn as_<T: Number>(self) -> T

impl<const BITS: usize> Number for UInt<u64, BITS>

const BITS: usize = BITS

Number of bits that can fit in this type

const MIN: Self

Minimum value that can be represented by this type

const MAX: Self

Maximum value that can be represented by this type

type UnderlyingType = u64

fn try_new(value: Self::UnderlyingType) -> Result<Self, TryNewError>

Creates a number from the given value, return None if the value is too large

fn new(value: u64) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when creating a value from a literal.

fn from_<T: Number>(value: T) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when the value is convertable to T. Use Self::new for literals.

fn masked_new<T: Number>(value: T) -> Self

Creates an instance from the given value. Unlike the various new... functions, this will never fail as the value is masked to the result size.

fn as_u8(&self) -> u8

fn as_u16(&self) -> u16

fn as_u32(&self) -> u32

fn as_u64(&self) -> u64

fn as_u128(&self) -> u128

fn as_usize(&self) -> usize

fn value(self) -> u64

fn as_<T: Number>(self) -> T

impl<const BITS: usize> Number for UInt<u8, BITS>

const BITS: usize = BITS

Number of bits that can fit in this type

const MIN: Self

Minimum value that can be represented by this type

const MAX: Self

Maximum value that can be represented by this type

type UnderlyingType = u8

fn try_new(value: Self::UnderlyingType) -> Result<Self, TryNewError>

Creates a number from the given value, return None if the value is too large

fn new(value: u8) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when creating a value from a literal.

fn from_<T: Number>(value: T) -> Self

Creates a number from the given value, throwing an error if the value is too large. This constructor is useful when the value is convertable to T. Use Self::new for literals.

fn masked_new<T: Number>(value: T) -> Self

Creates an instance from the given value. Unlike the various new... functions, this will never fail as the value is masked to the result size.

fn as_u8(&self) -> u8

fn as_u16(&self) -> u16

fn as_u32(&self) -> u32

fn as_u64(&self) -> u64

fn as_u128(&self) -> u128

fn as_usize(&self) -> usize

fn value(self) -> u8

fn as_<T: Number>(self) -> T

impl<T, const BITS: usize> Octal for UInt<T, BITS>

where T: Octal,

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

Formats the value using the given formatter.

impl<T: Ord, const BITS: usize> Ord for UInt<T, BITS>

fn cmp(&self, other: &UInt<T, BITS>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq, const BITS: usize> PartialEq for UInt<T, BITS>

fn eq(&self, other: &UInt<T, BITS>) -> bool

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd, const BITS: usize> PartialOrd for UInt<T, BITS>

fn partial_cmp(&self, other: &UInt<T, BITS>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<T, TSHIFTBITS, const BITS: usize> Shl<TSHIFTBITS> for UInt<T, BITS>

where Self: Number, T: Copy + BitAnd<T, Output = T> + Shl<TSHIFTBITS, Output = T> + Sub<T, Output = T> + Shl<usize, Output = T> + Shr<usize, Output = T> + From<u8>, TSHIFTBITS: TryInto<usize> + Copy,

type Output = UInt<T, BITS>

The resulting type after applying the << operator.

fn shl(self, rhs: TSHIFTBITS) -> Self::Output

Performs the << operation.

impl<T, TSHIFTBITS, const BITS: usize> ShlAssign<TSHIFTBITS> for UInt<T, BITS>

where Self: Number, T: Copy + BitAnd<T, Output = T> + BitAndAssign<T> + ShlAssign<TSHIFTBITS> + Sub<T, Output = T> + Shr<usize, Output = T> + Shl<usize, Output = T> + From<u8>, TSHIFTBITS: TryInto<usize> + Copy,

fn shl_assign(&mut self, rhs: TSHIFTBITS)

Performs the <<= operation.

impl<T, TSHIFTBITS, const BITS: usize> Shr<TSHIFTBITS> for UInt<T, BITS>

where T: Copy + Shr<TSHIFTBITS, Output = T> + Sub<T, Output = T> + Shl<usize, Output = T> + From<u8>, TSHIFTBITS: TryInto<usize> + Copy,

type Output = UInt<T, BITS>

The resulting type after applying the >> operator.

fn shr(self, rhs: TSHIFTBITS) -> Self::Output

Performs the >> operation.

impl<T, TSHIFTBITS, const BITS: usize> ShrAssign<TSHIFTBITS> for UInt<T, BITS>

where T: Copy + ShrAssign<TSHIFTBITS> + Sub<T, Output = T> + Shl<usize, Output = T> + From<u8>, TSHIFTBITS: TryInto<usize> + Copy,

fn shr_assign(&mut self, rhs: TSHIFTBITS)

Performs the >>= operation.

impl<T, const BITS: usize> Sub for UInt<T, BITS>

where Self: Number, T: Copy + BitAnd<T, Output = T> + Sub<T, Output = T>,

type Output = UInt<T, BITS>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T, const BITS: usize> SubAssign for UInt<T, BITS>

where Self: Number, T: Copy + SubAssign<T> + BitAnd<T, Output = T> + BitAndAssign<T> + Sub<T, Output = T>,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<T, const BITS: usize> UpperHex for UInt<T, BITS>

where T: UpperHex,

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

Formats the value using the given formatter.

impl<T: Copy, const BITS: usize> Copy for UInt<T, BITS>

impl<T: Eq, const BITS: usize> Eq for UInt<T, BITS>

impl<T, const BITS: usize> StructuralPartialEq for UInt<T, BITS>