Struct FixedUInt 

pub struct FixedUInt<T, const N: usize, P: Personality = Nct>
where
    T: MachineWord,
{ /* private fields */ }

Fixed-size unsigned integer, represented by array of N words of builtin unsigned type T.

The optional P: Personality parameter selects which implementations of operation primitives are used at each call site. Defaults to Nct (non-constant-time). Use FixedUInt<T, N, Ct> for values that must be handled in constant time. See const_num_traits::personality.

Implementations

impl<T: MachineWord, const N: usize, P: Personality> FixedUInt<T, N, P>

pub fn to_le_bytes_fixed<'a, const M: usize>( &self, out: &'a mut [u8; M], ) -> &'a [u8]

Serialize little-endian into a fixed-size buffer. The const M >= BYTE_WIDTH precondition fires at monomorphization, so wrong-size callers fail at compile time and the produced binary contains no runtime panic path from this method.

Returns the written prefix (&out[..BYTE_WIDTH]). If M > BYTE_WIDTH, the trailing bytes of out are left untouched.

use fixed_bigint::FixedUInt;
type U16 = FixedUInt<u8, 2>;
let v = U16::from(0x1234u16);
let mut buf = [0u8; U16::BYTE_WIDTH];
let bytes = v.to_le_bytes_fixed(&mut buf);
assert_eq!(bytes, &[0x34, 0x12]);

pub fn to_be_bytes_fixed<'a, const M: usize>( &self, out: &'a mut [u8; M], ) -> &'a [u8]

Big-endian counterpart of to_le_bytes_fixed; same const-asserted size guarantee and same panic-free intent.

Returns the written window &out[M - BYTE_WIDTH ..]. If M > BYTE_WIDTH, the leading bytes of out are left untouched — mirror image of to_le_bytes_fixed, aligning the value with the trailing window that from_be_bytes_fixed reads.

use fixed_bigint::FixedUInt;
type U16 = FixedUInt<u8, 2>;
let v = U16::from(0x1234u16);
let mut buf = [0u8; U16::BYTE_WIDTH];
let bytes = v.to_be_bytes_fixed(&mut buf);
assert_eq!(bytes, &[0x12, 0x34]);

pub fn from_le_bytes_fixed<const M: usize>(bytes: &[u8; M]) -> Self

Deserialize from a fixed-size little-endian buffer. The const M >= BYTE_WIDTH precondition fires at monomorphization. Reads the first BYTE_WIDTH bytes (LE low-order bytes are at the front); trailing bytes if M > BYTE_WIDTH are ignored.

use fixed_bigint::FixedUInt;
type U16 = FixedUInt<u8, 2>;
let buf = [0x34u8, 0x12];
let v = U16::from_le_bytes_fixed(&buf);
assert_eq!(v, U16::from(0x1234u16));

pub fn from_be_bytes_fixed<const M: usize>(bytes: &[u8; M]) -> Self

Deserialize from a fixed-size big-endian buffer. The const M >= BYTE_WIDTH precondition fires at monomorphization. Reads the last BYTE_WIDTH bytes (BE low-order bytes are at the end); leading bytes if M > BYTE_WIDTH are ignored.

use fixed_bigint::FixedUInt;
type U16 = FixedUInt<u8, 2>;
let buf = [0x12u8, 0x34];
let v = U16::from_be_bytes_fixed(&buf);
assert_eq!(v, U16::from(0x1234u16));

impl<T: ConstMachineWord + MachineWord, const N: usize> FixedUInt<T, N, Nct>

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

div_ceil variant returning None on divide-by-zero or overflow.

Not itself const fn — the c0nst! macro can’t emit [c0nst] bounds on inherent impls. Nightly callers wanting the const path call checked_div_ceil_impl (the free pub(crate) c0nst fn above) directly.

impl<T: ConstMachineWord + MachineWord, const N: usize> FixedUInt<T, N, Nct>

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

Unsigned isqrt cannot fail; always returns Some.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> FixedUInt<T, N, P>

pub fn from_power_of_two(p: PowerOfTwo<FixedUInt<T, N, P>>) -> Self

Reconstructs the value 1 << p.exp() proven by p. Symmetric with the safe upstream constructor PowerOfTwo::new_checked.

impl<T: ConstMachineWord + MachineWord, const N: usize> FixedUInt<T, N, Nct>

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

Inherent pow. FixedUInt does not implement external const_num_traits::PrimInt (which supertrait-bundles Num, NumCast, Saturating, and others), so this stays on the type itself. For const-callable use on nightly, call the free pow_impl function above directly.

impl<T: MachineWord, const N: usize> FixedUInt<T, N, Ct>

pub const fn forget_ct(self) -> FixedUInt<T, N, Nct>

Drop the CT guarantee and convert to the Nct variant.

This is an explicit downgrade. The caller is asserting that the value is no longer secret — typically because the CT-handling window has ended (e.g. a finalized signature, a published key, a post-reduction modular value about to be serialized).

impl<T: MachineWord + ConditionallySelectable, const N: usize> FixedUInt<T, N, Ct>

pub fn ct_checked_add(&self, other: &Self) -> CtOption<Self>

CT-friendly counterpart to num_traits::CheckedAdd::checked_add. Returns CtOption::new(res, Choice::from(!overflow)) — the result is always computed (always-iterate via overflowing_add), and the validity Choice carries the overflow flag without exposing it as a control-flow signal.

pub fn ct_checked_sub(&self, other: &Self) -> CtOption<Self>

CT-friendly counterpart to num_traits::CheckedSub::checked_sub.

pub fn ct_checked_mul(&self, other: &Self) -> CtOption<Self>

CT-friendly counterpart to num_traits::CheckedMul::checked_mul.

pub fn ct_checked_shl(&self, bits: u32) -> CtOption<Self>

CT-friendly counterpart to CheckedShl::checked_shl.

The value is computed via const_unbounded_shl_u32, which under Ct uses a branchless barrel shifter and a CT-safe min(bits, BIT_SIZE) clamp. The overflow flag (bits >= BIT_SIZE) is derived branchlessly here — never going through OverflowingShl::overflowing_shl which routes through normalize_shift_amount’s tainted branch + variable-time modulo.

pub fn ct_checked_shr(&self, bits: u32) -> CtOption<Self>

CT-friendly counterpart to CheckedShr::checked_shr.

Symmetric to Self::ct_checked_shl: value through const_unbounded_shr_u32, validity flag derived branchlessly.

pub fn ct_checked_next_power_of_two(self) -> CtOption<Self>

where T: ConstantTimeEq,

CT-friendly counterpart to NextPowerOfTwo::checked_next_power_of_two.

pub fn ct_checked_pow(self, exp: u32) -> CtOption<Self>

where T: ConstantTimeEq + ConstantTimeGreater, for<'a> &'a Self: Mul<&'a Self, Output = Self>,

impl<T: MachineWord, const N: usize, P: Personality> FixedUInt<T, N, P>

pub const BYTE_WIDTH: usize = Self::BYTE_SIZE

The serialized byte width of this FixedUInt type, N * size_of::<T>().

Public alias of the internal BYTE_SIZE for callers sizing buffers to feed the *_bytes_fixed panic-free byte conversion methods. Use as const BUF_LEN: usize = MyFixed::BYTE_WIDTH; then let mut buf = [0u8; BUF_LEN];.

pub fn new() -> FixedUInt<T, N, P>

Creates and zero-initializes a FixedUInt.

pub fn words(&self) -> &[T; N]

Returns the underlying array.

pub fn bit_length(&self) -> u32

Returns number of used bits.

impl<T: MachineWord, const N: usize> FixedUInt<T, N, Nct>

pub fn div_rem(&self, divisor: &Self) -> (Self, Self)

Performs a division, returning both the quotient and remainder in a tuple.

pub fn to_radix_str<'a>( &self, result: &'a mut [u8], radix: u8, ) -> Result<&'a str, Error>

Converts to decimal string, given a buffer. CAVEAT: This method removes any leading zeroes

impl<T: MachineWord, const N: usize, P: Personality> FixedUInt<T, N, P>

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

Create a little-endian integer value from its representation as a byte array in little endian.

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

Create a big-endian integer value from its representation as a byte array in big endian.

impl<T: MachineWord, const N: usize, P: Personality> FixedUInt<T, N, P>

pub fn to_le_bytes<'a>( &self, output_buffer: &'a mut [u8], ) -> Result<&'a [u8], bool>

Converts the FixedUInt into a little-endian byte array.

pub fn to_be_bytes<'a>( &self, output_buffer: &'a mut [u8], ) -> Result<&'a [u8], bool>

Converts the FixedUInt into a big-endian byte array.

pub fn to_hex_str<'a>(&self, result: &'a mut [u8]) -> Result<&'a str, Error>

Converts to hex string, given a buffer. CAVEAT: This method removes any leading zeroes

pub fn resize<const N2: usize>(&self) -> FixedUInt<T, N2, P>

Construct a new value with a different size.

• If N2 < N, the most-significant (upper) words are truncated.
• If N2 > N, the additional most-significant words are filled with zeros.

Trait Implementations

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> AbsDiff for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The result type: Self for unsigned types, the unsigned counterpart for signed types (so the difference always fits).

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

Computes the absolute difference between self and other without the possibility of overflow.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> AbsDiff for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The result type: Self for unsigned types, the unsigned counterpart for signed types (so the difference always fits).

fn abs_diff(self, other: Self) -> FixedUInt<T, N, P>

Computes the absolute difference between self and other without the possibility of overflow.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Add for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Add for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Add<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the + operator.

fn add(self, other: &Self) -> Self

Performs the + operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Add<FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the + operator.

fn add(self, other: FixedUInt<T, N, P>) -> Self::Output

Performs the + operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> AddAssign for FixedUInt<T, N, P>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> AddAssign<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

fn add_assign(&mut self, other: &Self)

Performs the += operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitAnd for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitAnd<&FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the & operator.

fn bitand(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the & operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitAnd<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the & operator.

fn bitand(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the & operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitAnd<FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the & operator.

fn bitand(self, other: FixedUInt<T, N, P>) -> Self::Output

Performs the & operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitAndAssign for FixedUInt<T, N, P>

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitOr for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitOr<&FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the | operator.

fn bitor(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the | operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitOr<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the | operator.

fn bitor(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the | operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitOr<FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the | operator.

fn bitor(self, other: FixedUInt<T, N, P>) -> Self::Output

Performs the | operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitOrAssign for FixedUInt<T, N, P>

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitWidth for FixedUInt<T, N, P>

fn bit_width(self) -> u32

Returns the minimum number of bits required to represent self, i.e. BITS - leading_zeros. Returns 0 for 0. Like std, this is only provided for unsigned types.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitWidth for &FixedUInt<T, N, P>

fn bit_width(self) -> u32

Returns the minimum number of bits required to represent self, i.e. BITS - leading_zeros. Returns 0 for 0. Like std, this is only provided for unsigned types.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitXor for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitXor<&FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the ^ operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitXor<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the ^ operator.

fn bitxor(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the ^ operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitXor<FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the ^ operator.

fn bitxor(self, other: FixedUInt<T, N, P>) -> Self::Output

Performs the ^ operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> BitXorAssign for FixedUInt<T, N, P>

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl<T: ConstMachineWord + BorrowingSub + MachineWord, const N: usize, P: Personality> BorrowingSub for FixedUInt<T, N, P>

fn borrowing_sub(self, rhs: Self, borrow: bool) -> (Self, bool)

Calculates self - rhs - borrow and returns a tuple containing the difference and the output borrow, performing the full subtraction rather than stopping at the first overflow.

impl<T: ConstMachineWord + BorrowingSub + MachineWord, const N: usize, P: Personality> BorrowingSub for &FixedUInt<T, N, P>

fn borrowing_sub(self, rhs: Self, borrow: bool) -> (FixedUInt<T, N, P>, bool)

Calculates self - rhs - borrow and returns a tuple containing the difference and the output borrow, performing the full subtraction rather than stopping at the first overflow.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Bounded for FixedUInt<T, N, P>

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<T: MachineWord, const N: usize, P: Personality> Bounded for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<T: ConstMachineWord + CarryingAdd + MachineWord, const N: usize, P: Personality> CarryingAdd for FixedUInt<T, N, P>

fn carrying_add(self, rhs: Self, carry: bool) -> (Self, bool)

Calculates self + rhs + carry and returns a tuple containing the sum and the output carry, performing the full addition rather than stopping at the first overflow.

impl<T: ConstMachineWord + CarryingAdd + MachineWord, const N: usize, P: Personality> CarryingAdd for &FixedUInt<T, N, P>

fn carrying_add(self, rhs: Self, carry: bool) -> (FixedUInt<T, N, P>, bool)

Calculates self + rhs + carry and returns a tuple containing the sum and the output carry, performing the full addition rather than stopping at the first overflow.

impl<T: ConstMachineWord + CarryingAdd + BorrowingSub + MachineWord, const N: usize, P: Personality> CarryingMul for FixedUInt<T, N, P>

where <T as ConstMachineWord>::ConstDoubleWord: Mul<Output = <T as ConstMachineWord>::ConstDoubleWord> + BitAnd<Output = <T as ConstMachineWord>::ConstDoubleWord> + Shr<usize, Output = <T as ConstMachineWord>::ConstDoubleWord>,

type Unsigned = FixedUInt<T, N, P>

The type of the low half of the result: Self for unsigned types, the unsigned counterpart for signed types (matching std’s carrying_mul signatures).

fn carrying_mul(self, rhs: Self, carry: Self) -> (Self, Self)

Calculates the “full multiplication” self * rhs + carry without the possibility to overflow, returning (low, high) words of the result.

fn carrying_mul_add(self, rhs: Self, addend: Self, carry: Self) -> (Self, Self)

Calculates the “full multiplication” self * rhs + carry + add without the possibility to overflow, returning (low, high) words.

impl<T: ConstMachineWord + CarryingAdd + BorrowingSub + MachineWord, const N: usize, P: Personality> CarryingMul for &FixedUInt<T, N, P>

where <T as ConstMachineWord>::ConstDoubleWord: Mul<Output = <T as ConstMachineWord>::ConstDoubleWord> + BitAnd<Output = <T as ConstMachineWord>::ConstDoubleWord> + Shr<usize, Output = <T as ConstMachineWord>::ConstDoubleWord>,

type Unsigned = FixedUInt<T, N, P>

The type of the low half of the result: Self for unsigned types, the unsigned counterpart for signed types (matching std’s carrying_mul signatures).

fn carrying_mul( self, rhs: Self, carry: Self, ) -> (FixedUInt<T, N, P>, FixedUInt<T, N, P>)

Calculates the “full multiplication” self * rhs + carry without the possibility to overflow, returning (low, high) words of the result.

fn carrying_mul_add( self, rhs: Self, addend: Self, carry: Self, ) -> (FixedUInt<T, N, P>, FixedUInt<T, N, P>)

Calculates the “full multiplication” self * rhs + carry + add without the possibility to overflow, returning (low, high) words.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedAdd for FixedUInt<T, N, P>

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

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedAdd for &FixedUInt<T, N, P>

fn checked_add(self, other: Self) -> Option<FixedUInt<T, N, P>>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<T: MachineWord, const N: usize, P: Personality> CheckedAdd for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn checked_add(&self, other: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedDiv for FixedUInt<T, N, Nct>

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

Divides two numbers, checking for overflow and division by zero. If any of that happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedDiv for &FixedUInt<T, N, Nct>

fn checked_div(self, other: Self) -> Option<FixedUInt<T, N, Nct>>

Divides two numbers, checking for overflow and division by zero. If any of that happens, None is returned.

impl<T: MachineWord, const N: usize> CheckedDiv for FixedUInt<T, N, Nct>

Available on crate feature num-traits only.

fn checked_div(&self, other: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedEuclid for FixedUInt<T, N, Nct>

fn checked_div_euclid(self, v: Self) -> Option<Self>

Performs euclid division, returning None on division by zero or if overflow occurred.

fn checked_rem_euclid(self, v: Self) -> Option<Self>

Finds the euclid remainder of dividing two numbers, returning None on division by zero or if overflow occurred.

fn checked_div_rem_euclid(self, v: Self) -> Option<(Self, Self)>

Returns both the quotient and remainder from checked Euclidean division, returning None on division by zero or if overflow occurred.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedEuclid for &FixedUInt<T, N, Nct>

fn checked_div_euclid(self, v: Self) -> Option<FixedUInt<T, N, Nct>>

Performs euclid division, returning None on division by zero or if overflow occurred.

fn checked_rem_euclid(self, v: Self) -> Option<FixedUInt<T, N, Nct>>

Finds the euclid remainder of dividing two numbers, returning None on division by zero or if overflow occurred.

fn checked_div_rem_euclid( self, v: Self, ) -> Option<(FixedUInt<T, N, Nct>, FixedUInt<T, N, Nct>)>

Returns both the quotient and remainder from checked Euclidean division, returning None on division by zero or if overflow occurred.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedMul for FixedUInt<T, N, P>

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

Multiplies two numbers, checking for overflow. If overflow happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedMul for &FixedUInt<T, N, P>

fn checked_mul(self, other: Self) -> Option<FixedUInt<T, N, P>>

Multiplies two numbers, checking for overflow. If overflow happens, None is returned.

impl<T: MachineWord, const N: usize, P: Personality> CheckedMul for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn checked_mul(&self, other: &Self) -> Option<Self>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedPow for FixedUInt<T, N, Nct>

fn checked_pow(self, exp: u32) -> Option<Self>

Checked exponentiation. Computes self.pow(exp), returning None if overflow occurred.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedPow for &FixedUInt<T, N, Nct>

fn checked_pow(self, exp: u32) -> Option<FixedUInt<T, N, Nct>>

Checked exponentiation. Computes self.pow(exp), returning None if overflow occurred.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedRem for FixedUInt<T, N, Nct>

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

Finds the remainder of dividing two numbers, checking for overflow and division by zero. If any of that happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize> CheckedRem for &FixedUInt<T, N, Nct>

fn checked_rem(self, other: Self) -> Option<FixedUInt<T, N, Nct>>

Finds the remainder of dividing two numbers, checking for overflow and division by zero. If any of that happens, None is returned.

impl<T: MachineWord, const N: usize> CheckedRem for FixedUInt<T, N, Nct>

Available on crate feature num-traits only.

fn checked_rem(&self, other: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedShl for FixedUInt<T, N, P>

fn checked_shl(self, bits: u32) -> Option<Self>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedShl for &FixedUInt<T, N, P>

fn checked_shl(self, bits: u32) -> Option<FixedUInt<T, N, P>>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<T: MachineWord, const N: usize, P: Personality> CheckedShl for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn checked_shl(&self, bits: u32) -> Option<Self>

Checked shift left. Computes self << rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedShr for FixedUInt<T, N, P>

fn checked_shr(self, bits: u32) -> Option<Self>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedShr for &FixedUInt<T, N, P>

fn checked_shr(self, bits: u32) -> Option<FixedUInt<T, N, P>>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<T: MachineWord, const N: usize, P: Personality> CheckedShr for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn checked_shr(&self, bits: u32) -> Option<Self>

Checked shift right. Computes self >> rhs, returning None if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedSub for FixedUInt<T, N, P>

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

Subtracts two numbers, checking for overflow. If overflow happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> CheckedSub for &FixedUInt<T, N, P>

fn checked_sub(self, other: Self) -> Option<FixedUInt<T, N, P>>

Subtracts two numbers, checking for overflow. If overflow happens, None is returned.

impl<T: MachineWord, const N: usize, P: Personality> CheckedSub for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn checked_sub(&self, other: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Clone for FixedUInt<T, N, P>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: MachineWord + ConditionallySelectable, const N: usize> ConditionallySelectable for FixedUInt<T, N, Ct>

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ConstOne for FixedUInt<T, N, P>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ConstZero for FixedUInt<T, N, P>

const ZERO: Self

The additive identity element of Self, 0.

impl<T: MachineWord + ConstantTimeEq, const N: usize> ConstantTimeEq for FixedUInt<T, N, Ct>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<T: MachineWord + ConstantTimeEq + ConstantTimeGreater, const N: usize> ConstantTimeGreater for FixedUInt<T, N, Ct>

fn ct_gt(&self, other: &Self) -> Choice

Determine whether self > other.

impl<T: MachineWord + ConstantTimeEq + ConstantTimeGreater, const N: usize> ConstantTimeLess for FixedUInt<T, N, Ct>

fn ct_lt(&self, other: &Self) -> Choice

Determine whether self < other.

impl<T, const N: usize, P: Copy + Personality> Copy for FixedUInt<T, N, P>

where T: MachineWord + Copy,

impl<T: MachineWord, const N: usize, P: Personality> CtCheckedAdd for FixedUInt<T, N, P>

fn ct_checked_add(&self, v: &Self) -> CtOption<Self>

Computes self + v, returning a CtOption that is None-masked on overflow.

impl<T, const N: usize, P: Personality> CtCheckedMul for FixedUInt<T, N, P>

where T: MachineWord,

fn ct_checked_mul(&self, v: &Self) -> CtOption<Self>

Computes self * v, returning a CtOption that is None-masked on overflow.

impl<T: MachineWord, const N: usize, P: Personality> CtCheckedSub for FixedUInt<T, N, P>

fn ct_checked_sub(&self, v: &Self) -> CtOption<Self>

Computes self - v, returning a CtOption that is None-masked on overflow.

impl<T, const N: usize, P: Personality> CtIsPowerOfTwo for FixedUInt<T, N, P>

where T: MachineWord + ConstantTimeEq,

fn ct_is_power_of_two(&self) -> Choice

Returns a masked true if self is a power of two.

impl<T, const N: usize, P: Personality> CtIsZero for FixedUInt<T, N, P>

where T: MachineWord + ConstantTimeEq,

fn ct_is_zero(&self) -> Choice

Returns a masked true if self is zero.

impl<T, const N: usize, P: Personality> CtNonZero for FixedUInt<T, N, P>

where T: MachineWord + ConstantTimeEq,

fn into_nonzero_ct(self) -> CtOption<Self::NonZero>

None-masked when self == 0.

impl<T, const N: usize, P: Personality> CtParity for FixedUInt<T, N, P>

where T: MachineWord + ConstantTimeEq,

fn ct_is_odd(&self) -> Choice

LSB of word 0, masked through subtle::ConstantTimeEq against ZERO. Same body for both personalities — under Nct, the branchless form is still correct, just unnecessary for CT hygiene; under Ct, this is the path that keeps the result masked all the way to Odd::new_ct.

fn ct_is_even(&self) -> Choice

Returns a masked true if self is even.

impl<T: MachineWord + Debug, const N: usize> Debug for FixedUInt<T, N, Nct>

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

Formats the value using the given formatter.

impl<T: MachineWord, const N: usize> Debug for FixedUInt<T, N, Ct>

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

Formats the value using the given formatter.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Default for FixedUInt<T, N, P>

fn default() -> Self

Returns the “default value” for a type.

impl<T: ConstMachineWord + MachineWord, const N: usize> DepositBits for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

Scatters the contiguous low-order bits of self into the positions of the one-bits of mask (the PDEP operation). All other bits of the result are zero. Like std, this is only provided for unsigned types.

fn deposit_bits(self, mask: Self) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize> DepositBits for &FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

Scatters the contiguous low-order bits of self into the positions of the one-bits of mask (the PDEP operation). All other bits of the result are zero. Like std, this is only provided for unsigned types.

fn deposit_bits(self, mask: Self) -> FixedUInt<T, N, Nct>

impl<T: MachineWord, const N: usize> Display for FixedUInt<T, N, Nct>

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

Formats the value using the given formatter.

impl<T: ConstMachineWord + MachineWord, const N: usize> Div for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> Div<&FixedUInt<T, N>> for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the / operator.

fn div(self, other: &FixedUInt<T, N, Nct>) -> Self::Output

Performs the / operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> Div<&FixedUInt<T, N>> for &FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the / operator.

fn div(self, other: &FixedUInt<T, N, Nct>) -> Self::Output

Performs the / operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> Div<FixedUInt<T, N>> for &FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the / operator.

fn div(self, other: FixedUInt<T, N, Nct>) -> Self::Output

Performs the / operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> DivAssign for FixedUInt<T, N, Nct>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> DivAssign<&FixedUInt<T, N>> for FixedUInt<T, N, Nct>

fn div_assign(&mut self, other: &FixedUInt<T, N, Nct>)

Performs the /= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> DivCeil for FixedUInt<T, N, Nct>

fn div_ceil(self, rhs: Self) -> Self

Calculates the quotient of self and rhs, rounding the result towards positive infinity.

impl<T: ConstMachineWord + MachineWord, const N: usize> DivCeil for &FixedUInt<T, N, Nct>

fn div_ceil(self, rhs: Self) -> FixedUInt<T, N, Nct>

Calculates the quotient of self and rhs, rounding the result towards positive infinity.

impl<T: ConstMachineWord + MachineWord, const N: usize> DivNonZero for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

Owned result. A fresh Output — the divisor is Self::NonZero, not Self, so Div::Output cannot be reused.

fn div_nonzero(self, d: Self::NonZero) -> Self::Output

self / d, infallibly.

fn rem_nonzero(self, d: Self::NonZero) -> Self::Output

self % d, infallibly.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Eq for FixedUInt<T, N, P>

impl<T: ConstMachineWord + MachineWord, const N: usize> Euclid for FixedUInt<T, N, Nct>

fn div_euclid(self, v: Self) -> Self

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(self, v: Self) -> Self

Calculates the least nonnegative remainder of self (mod v).

fn div_rem_euclid(self, v: Self) -> (Self, Self)

Returns both the quotient and remainder from Euclidean division.

impl<T: ConstMachineWord + MachineWord, const N: usize> Euclid for &FixedUInt<T, N, Nct>

fn div_euclid(self, v: Self) -> FixedUInt<T, N, Nct>

Calculates Euclidean division, the matching method for rem_euclid.

fn rem_euclid(self, v: Self) -> FixedUInt<T, N, Nct>

Calculates the least nonnegative remainder of self (mod v).

fn div_rem_euclid(self, v: Self) -> (FixedUInt<T, N, Nct>, FixedUInt<T, N, Nct>)

Returns both the quotient and remainder from Euclidean division.

impl<T: ConstMachineWord + MachineWord, const N: usize> ExtractBits for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

Gathers the bits of self selected by the one-bits of mask into the contiguous low-order bits of the result (the PEXT operation). Like std, this is only provided for unsigned types.

fn extract_bits(self, mask: Self) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize> ExtractBits for &FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

Gathers the bits of self selected by the one-bits of mask into the contiguous low-order bits of the result (the PEXT operation). Like std, this is only provided for unsigned types.

fn extract_bits(self, mask: Self) -> FixedUInt<T, N, Nct>

impl<T: MachineWord, const N: usize> From<FixedUInt<T, N>> for FixedUInt<T, N, Ct>

Lossless conversion from Nct to Ct. Tightens the invariant (declares that the value will be handled under the CT threat model going forward). Bit representation is identical; this is a free reinterpretation.

fn from(v: FixedUInt<T, N, Nct>) -> Self

Converts to this type from the input type.

impl<T, const N: usize, P: Personality> From<[T; N]> for FixedUInt<T, N, P>

where T: MachineWord,

fn from(array: [T; N]) -> Self

Converts to this type from the input type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> From<u8> for FixedUInt<T, N, P>

fn from(x: u8) -> Self

Converts to this type from the input type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> From<u16> for FixedUInt<T, N, P>

fn from(x: u16) -> Self

Converts to this type from the input type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> From<u32> for FixedUInt<T, N, P>

fn from(x: u32) -> Self

Converts to this type from the input type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> From<u64> for FixedUInt<T, N, P>

fn from(x: u64) -> Self

Converts to this type from the input type.

impl<T: MachineWord, const N: usize, P: Personality> FromByteSlice for FixedUInt<T, N, P>

fn from_be_slice(bytes: &[u8]) -> Result<Self, ByteSliceError>

Parses from a big-endian byte slice.

fn from_le_slice(bytes: &[u8]) -> Result<Self, ByteSliceError>

Parses from a little-endian byte slice.

impl<T: MachineWord, const N: usize, P: Personality> FromPrimitive for FixedUInt<T, N, P>

fn from_i64(_: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(input: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Self>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Self>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl<T: MachineWord, const N: usize> FromStr for FixedUInt<T, N, Nct>

Available on crate feature num-traits only.

type Err = ParseIntError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> FunnelShl for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Funnel shift left: concatenates self (high word) with rhs (low word), shifts the combination left by n, and returns the high word — i.e. (self << n) | (rhs >> (BITS - n)). Like std, this is only provided for unsigned types.

fn funnel_shl(self, rhs: Self, n: u32) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> FunnelShl for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Funnel shift left: concatenates self (high word) with rhs (low word), shifts the combination left by n, and returns the high word — i.e. (self << n) | (rhs >> (BITS - n)). Like std, this is only provided for unsigned types.

fn funnel_shl(self, rhs: Self, n: u32) -> FixedUInt<T, N, P>

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> FunnelShr for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Funnel shift right: concatenates self (high word) with rhs (low word), shifts the combination right by n, and returns the low word — i.e. (rhs >> n) | (self << (BITS - n)). Like std, this is only provided for unsigned types.

fn funnel_shr(self, rhs: Self, n: u32) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> FunnelShr for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Funnel shift right: concatenates self (high word) with rhs (low word), shifts the combination right by n, and returns the low word — i.e. (rhs >> n) | (self << (BITS - n)). Like std, this is only provided for unsigned types.

fn funnel_shr(self, rhs: Self, n: u32) -> FixedUInt<T, N, P>

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> HasNonZero for FixedUInt<T, N, P>

type NonZero = NonZeroFixedUInt<T, N, P>

The non-zero form of Self (core::num::NonZero<Self> for primitives).

fn into_nonzero(self) -> Option<Self::NonZero>

Some iff self != 0.

fn nonzero_get(nz: Self::NonZero) -> Self

Recover the underlying value from its non-zero form.

impl<T: MachineWord, const N: usize, P: Personality> HasPersonality for FixedUInt<T, N, P>

type P = P

The carrier’s personality.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> HighestOne for FixedUInt<T, N, P>

fn highest_one(self) -> Option<u32>

Returns the index of the highest bit set to one, or None if the value is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> HighestOne for &FixedUInt<T, N, P>

fn highest_one(self) -> Option<u32>

Returns the index of the highest bit set to one, or None if the value is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize> Ilog for FixedUInt<T, N, Nct>

fn ilog(self, base: Self) -> u32

Returns the logarithm of the number with respect to base, rounded down.

fn checked_ilog(self, base: Self) -> Option<u32>

Returns the logarithm of the number with respect to base, rounded down, or None if the number is zero (or negative, for signed types) or if base is less than 2.

impl<T: ConstMachineWord + MachineWord, const N: usize> Ilog for &FixedUInt<T, N, Nct>

fn ilog(self, base: Self) -> u32

Returns the logarithm of the number with respect to base, rounded down.

fn checked_ilog(self, base: Self) -> Option<u32>

Returns the logarithm of the number with respect to base, rounded down, or None if the number is zero (or negative, for signed types) or if base is less than 2.

impl<T: ConstMachineWord + MachineWord, const N: usize> Ilog2 for FixedUInt<T, N, Nct>

fn ilog2(self) -> u32

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

fn checked_ilog2(self) -> Option<u32>

Returns the base 2 logarithm of the number, rounded down, or None if the number is zero (or negative, for signed types).

impl<T: ConstMachineWord + MachineWord, const N: usize> Ilog2 for &FixedUInt<T, N, Nct>

fn ilog2(self) -> u32

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

fn checked_ilog2(self) -> Option<u32>

Returns the base 2 logarithm of the number, rounded down, or None if the number is zero (or negative, for signed types).

impl<T: ConstMachineWord + MachineWord, const N: usize> Ilog10 for FixedUInt<T, N, Nct>

fn ilog10(self) -> u32

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

fn checked_ilog10(self) -> Option<u32>

Returns the base 10 logarithm of the number, rounded down, or None if the number is zero (or negative, for signed types).

impl<T: ConstMachineWord + MachineWord, const N: usize> Ilog10 for &FixedUInt<T, N, Nct>

fn ilog10(self) -> u32

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

fn checked_ilog10(self) -> Option<u32>

Returns the base 10 logarithm of the number, rounded down, or None if the number is zero (or negative, for signed types).

impl<T: MachineWord, const N: usize> Integer for FixedUInt<T, N, Nct>

fn div_floor(&self, other: &Self) -> Self

Floored integer division.

fn mod_floor(&self, other: &Self) -> Self

Floored integer modulo, satisfying:

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

Greatest Common Divisor (GCD).

fn lcm(&self, other: &Self) -> Self

Lowest Common Multiple (LCM).

fn divides(&self, other: &Self) -> bool

👎Deprecated:

Please use is_multiple_of instead

Deprecated, use is_multiple_of instead.

fn is_multiple_of(&self, other: &Self) -> bool

Returns true if self is a multiple of other.

fn is_even(&self) -> bool

Returns true if the number is even.

fn is_odd(&self) -> bool

Returns true if the number is odd.

fn div_rem(&self, other: &Self) -> (Self, Self)

Simultaneous truncated integer division and modulus. Returns (quotient, remainder).

fn div_ceil(&self, other: &Self) -> Self

Ceiled integer division.

fn gcd_lcm(&self, other: &Self) -> (Self, Self)

Greatest Common Divisor (GCD) and Lowest Common Multiple (LCM) together.

fn extended_gcd(&self, other: &Self) -> ExtendedGcd<Self>

where Self: Clone,

Greatest common divisor and Bézout coefficients.

fn div_mod_floor(&self, other: &Self) -> (Self, Self)

Simultaneous floored integer division and modulus. Returns (quotient, remainder).

fn next_multiple_of(&self, other: &Self) -> Self

where Self: Clone,

Rounds up to nearest multiple of argument.

fn prev_multiple_of(&self, other: &Self) -> Self

where Self: Clone,

Rounds down to nearest multiple of argument.

fn dec(&mut self)

where Self: Clone,

Decrements self by one.

fn inc(&mut self)

where Self: Clone,

Increments self by one.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> IsPowerOfTwo for FixedUInt<T, N, P>

fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some integer k. Zero is not a power of two.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> IsPowerOfTwo for &FixedUInt<T, N, P>

fn is_power_of_two(self) -> bool

Returns true if and only if self == 2^k for some integer k. Zero is not a power of two.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> IsolateHighestOne for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Returns self with only its highest one-bit kept, or 0 if the value is zero.

fn isolate_highest_one(self) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> IsolateHighestOne for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Returns self with only its highest one-bit kept, or 0 if the value is zero.

fn isolate_highest_one(self) -> FixedUInt<T, N, P>

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> IsolateLowestOne for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Returns self with only its lowest one-bit kept, or 0 if the value is zero.

fn isolate_lowest_one(self) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> IsolateLowestOne for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Returns self with only its lowest one-bit kept, or 0 if the value is zero.

fn isolate_lowest_one(self) -> FixedUInt<T, N, P>

impl<T: ConstMachineWord + MachineWord, const N: usize> Isqrt for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

Returns the integer square root: the largest integer r such that r * r <= self.

fn isqrt(self) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize> Isqrt for &FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

Returns the integer square root: the largest integer r such that r * r <= self.

fn isqrt(self) -> FixedUInt<T, N, Nct>

impl<T: MachineWord, const N: usize> LowerHex for FixedUInt<T, N, Nct>

where u8: TryFrom<T>,

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

Formats the value using the given formatter.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> LowestOne for FixedUInt<T, N, P>

fn lowest_one(self) -> Option<u32>

Returns the index of the lowest bit set to one, or None if the value is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> LowestOne for &FixedUInt<T, N, P>

fn lowest_one(self) -> Option<u32>

Returns the index of the lowest bit set to one, or None if the value is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Midpoint for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Calculates the midpoint (self + rhs) / 2 as if it were performed in a sufficiently-large type, so it never overflows. The result is rounded towards zero.

fn midpoint(self, rhs: Self) -> Self

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Midpoint for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

Calculates the midpoint (self + rhs) / 2 as if it were performed in a sufficiently-large type, so it never overflows. The result is rounded towards zero.

fn midpoint(self, rhs: Self) -> FixedUInt<T, N, P>

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Mul for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Mul<&&FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the * operator.

fn mul(self, other: &&FixedUInt<T, N, P>) -> Self::Output

Performs the * operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Mul<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the * operator.

fn mul(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the * operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Mul<&FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the * operator.

fn mul(self, other: &FixedUInt<T, N, P>) -> Self::Output

Performs the * operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Mul<FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the * operator.

fn mul(self, other: FixedUInt<T, N, P>) -> Self::Output

Performs the * operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> MulAssign for FixedUInt<T, N, P>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> MulAssign<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

fn mul_assign(&mut self, other: &FixedUInt<T, N, P>)

Performs the *= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> MultipleOf for FixedUInt<T, N, Nct>

fn is_multiple_of(self, rhs: Self) -> bool

Returns true if self is an integer multiple of rhs, and false otherwise.

impl<T: ConstMachineWord + MachineWord, const N: usize> MultipleOf for &FixedUInt<T, N, Nct>

fn is_multiple_of(self, rhs: Self) -> bool

Returns true if self is an integer multiple of rhs, and false otherwise.

impl<T: ConstMachineWord + MachineWord, const N: usize> NextMultipleOf for FixedUInt<T, N, Nct>

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

Calculates the smallest value greater than or equal to self that is a multiple of rhs (for negative rhs on signed types: the closest to negative infinity).

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, returning None if rhs is zero or the operation would result in overflow.

impl<T: ConstMachineWord + MachineWord, const N: usize> NextMultipleOf for &FixedUInt<T, N, Nct>

fn next_multiple_of(self, rhs: Self) -> FixedUInt<T, N, Nct>

Calculates the smallest value greater than or equal to self that is a multiple of rhs (for negative rhs on signed types: the closest to negative infinity).

fn checked_next_multiple_of(self, rhs: Self) -> Option<FixedUInt<T, N, Nct>>

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> NextPowerOfTwo for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

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

fn wrapping_next_power_of_two(self) -> Self

Returns the smallest power of two greater than or equal to self, or 0 if it doesn’t fit in the type (i.e. the result wraps to zero).

fn next_power_of_two(self) -> Self

fn checked_next_power_of_two(self) -> Option<Self>

Returns the smallest power of two greater than or equal to self, or None if it doesn’t fit in the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> NextPowerOfTwo for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

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

fn next_power_of_two(self) -> FixedUInt<T, N, P>

fn checked_next_power_of_two(self) -> Option<FixedUInt<T, N, P>>

Returns the smallest power of two greater than or equal to self, or None if it doesn’t fit in the type.

fn wrapping_next_power_of_two(self) -> FixedUInt<T, N, P>

Returns the smallest power of two greater than or equal to self, or 0 if it doesn’t fit in the type (i.e. the result wraps to zero).

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Not for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: MachineWord, const N: usize> Num for FixedUInt<T, N, Nct>

Available on crate feature num-traits only.

type FromStrRadixErr = ParseIntError

fn from_str_radix( input: &str, radix: u32, ) -> Result<Self, <Self as Num>::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<T: MachineWord, const N: usize, P: Personality> NumCast for FixedUInt<T, N, P>

fn from<X>(arg: X) -> Option<Self>

where X: ToPrimitive,

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> One for FixedUInt<T, N, P>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<T: MachineWord, const N: usize, P: Personality> One for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Ord for FixedUInt<T, N, P>

fn cmp(&self, other: &Self) -> 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: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingAdd for FixedUInt<T, N, P>

fn overflowing_add(self, other: Self) -> (Self, bool)

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingAdd for &FixedUInt<T, N, P>

fn overflowing_add(self, other: Self) -> (FixedUInt<T, N, P>, bool)

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

impl<T: MachineWord, const N: usize, P: Personality> OverflowingAdd for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn overflowing_add(&self, other: &Self) -> (Self, bool)

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

impl<T: MachineWord, const N: usize, P: Personality> OverflowingMul for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn overflowing_mul(&self, other: &Self) -> (Self, bool)

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingMul for FixedUInt<T, N, P>

fn overflowing_mul(self, other: Self) -> (Self, bool)

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingMul for &FixedUInt<T, N, P>

fn overflowing_mul(self, other: Self) -> (FixedUInt<T, N, P>, bool)

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingShl for FixedUInt<T, N, P>

fn overflowing_shl(self, bits: u32) -> (Self, bool)

Shifts self left by a rhs masked to the bit width of the type, and returns a boolean indicating whether rhs was larger than or equal to the number of bits.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingShl for &FixedUInt<T, N, P>

fn overflowing_shl(self, bits: u32) -> (FixedUInt<T, N, P>, bool)

Shifts self left by a rhs masked to the bit width of the type, and returns a boolean indicating whether rhs was larger than or equal to the number of bits.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingShr for FixedUInt<T, N, P>

fn overflowing_shr(self, bits: u32) -> (Self, bool)

Shifts self right by a rhs masked to the bit width of the type, and returns a boolean indicating whether rhs was larger than or equal to the number of bits.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingShr for &FixedUInt<T, N, P>

fn overflowing_shr(self, bits: u32) -> (FixedUInt<T, N, P>, bool)

Shifts self right by a rhs masked to the bit width of the type, and returns a boolean indicating whether rhs was larger than or equal to the number of bits.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingSub for FixedUInt<T, N, P>

fn overflowing_sub(self, other: Self) -> (Self, bool)

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> OverflowingSub for &FixedUInt<T, N, P>

fn overflowing_sub(self, other: Self) -> (FixedUInt<T, N, P>, bool)

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

impl<T: MachineWord, const N: usize, P: Personality> OverflowingSub for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn overflowing_sub(&self, other: &Self) -> (Self, bool)

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

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Parity for FixedUInt<T, N, P>

fn is_odd(self) -> bool

Returns true if self is odd.

fn is_even(self) -> bool

Returns true if self is even.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> PartialEq for FixedUInt<T, N, P>

fn eq(&self, other: &Self) -> 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: ConstMachineWord + MachineWord, const N: usize, P: Personality> PartialOrd for FixedUInt<T, N, P>

fn partial_cmp(&self, other: &Self) -> 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: ConstMachineWord + MachineWord, const N: usize, P: Personality> PowerOfTwoOps for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The owned result type (Self for the primitive impls).

fn div_pow2(self, p: PowerOfTwo<Self>) -> Self

self / p, computed as self >> p.exp().

fn rem_pow2(self, p: PowerOfTwo<Self>) -> Self

self % p, computed as self & ((1 << p.exp()) - 1).

fn is_multiple_of_pow2(self, p: PowerOfTwo<Self>) -> bool

self % p == 0, computed as a mask test (no division).

fn next_multiple_of_pow2(self, p: PowerOfTwo<Self>) -> Self

Smallest multiple of p that is >= self (“align up”), computed branch-free as (self + mask) & !mask. Uses +, so it panics on overflow in debug (and the const-eval form errors) when self is within p of the maximum — use checked_next_multiple_of_pow2 for untrusted input.

fn checked_next_multiple_of_pow2(self, p: PowerOfTwo<Self>) -> Option<Self>

next_multiple_of_pow2, returning None on overflow instead of panicking.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> PrimBits for FixedUInt<T, N, P>

fn count_ones(self) -> u32

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

fn count_zeros(self) -> u32

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

fn leading_zeros(self) -> u32

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

fn trailing_zeros(self) -> u32

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

fn swap_bytes(self) -> Self

Reverses the byte order of the integer.

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.

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.

fn unsigned_shl(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, filling zeros in the least significant bits.

fn unsigned_shr(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, filling zeros in the most significant bits.

fn signed_shl(self, n: u32) -> Self

Shifts the bits to the left by a specified amount, n, filling zeros in the least significant bits.

fn signed_shr(self, n: u32) -> Self

Shifts the bits to the right by a specified amount, n, copying the “sign bit” in the most significant bits even for unsigned types.

fn reverse_bits(self) -> Self

Reverses the order of bits in the integer.

fn from_be(x: Self) -> Self

Convert an integer from big endian to the target’s endianness.

fn from_le(x: Self) -> Self

Convert an integer from little endian to the target’s endianness.

fn to_be(self) -> Self

Convert self to big endian from the target’s endianness.

fn to_le(self) -> Self

Convert self to little endian from the target’s endianness.

fn leading_ones(self) -> u32

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

fn trailing_ones(self) -> u32

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

impl<T: MachineWord, const N: usize> PrimInt for FixedUInt<T, N, Nct>

Available on crate feature num-traits only.

fn count_ones(self) -> u32

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

fn count_zeros(self) -> u32

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

fn leading_zeros(self) -> u32

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

fn trailing_zeros(self) -> u32

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

fn rotate_left(self, bits: u32) -> Self

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

fn rotate_right(self, bits: u32) -> Self

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

fn signed_shl(self, bits: u32) -> Self

Shifts the bits to the left by a specified amount, n, filling zeros in the least significant bits.

fn signed_shr(self, bits: u32) -> Self

Shifts the bits to the right by a specified amount, n, copying the “sign bit” in the most significant bits even for unsigned types.

fn unsigned_shl(self, bits: u32) -> Self

Shifts the bits to the left by a specified amount, n, filling zeros in the least significant bits.

fn unsigned_shr(self, bits: u32) -> Self

Shifts the bits to the right by a specified amount, n, filling zeros in the most significant bits.

fn swap_bytes(self) -> Self

Reverses the byte order of the integer.

fn from_be(source: Self) -> Self

Convert an integer from big endian to the target’s endianness.

fn from_le(source: Self) -> Self

Convert an integer from little endian to the target’s endianness.

fn to_be(self) -> Self

Convert self to big endian from the target’s endianness.

fn to_le(self) -> Self

Convert self to little endian from the target’s endianness.

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

Raises self to the power of exp, using exponentiation by squaring.

fn leading_ones(self) -> u32

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

fn trailing_ones(self) -> u32

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

fn reverse_bits(self) -> Self

Reverses the order of bits in the integer.

impl<T: MachineWord, const N: usize, P: Personality> Product for FixedUInt<T, N, P>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

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

impl<'a, T: MachineWord, const N: usize, P: Personality> Product<&'a FixedUInt<T, N, P>> for FixedUInt<T, N, P>

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

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

impl<T: ConstMachineWord + MachineWord, const N: usize> Rem for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the % operator.

fn rem(self, other: Self) -> Self::Output

Performs the % operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> Rem<&FixedUInt<T, N>> for FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the % operator.

fn rem(self, other: &FixedUInt<T, N, Nct>) -> Self::Output

Performs the % operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> Rem<&FixedUInt<T, N>> for &FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the % operator.

fn rem(self, other: &FixedUInt<T, N, Nct>) -> Self::Output

Performs the % operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> Rem<FixedUInt<T, N>> for &FixedUInt<T, N, Nct>

type Output = FixedUInt<T, N>

The resulting type after applying the % operator.

fn rem(self, other: FixedUInt<T, N, Nct>) -> Self::Output

Performs the % operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> RemAssign for FixedUInt<T, N, Nct>

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize> RemAssign<&FixedUInt<T, N>> for FixedUInt<T, N, Nct>

fn rem_assign(&mut self, other: &FixedUInt<T, N, Nct>)

Performs the %= operation.

impl<T: MachineWord, const N: usize> Roots for FixedUInt<T, N, Nct>

fn nth_root(&self, n: u32) -> Self

Returns the truncated principal nth root of an integer – if x >= 0 { ⌊ⁿ√x⌋ } else { ⌈ⁿ√x⌉ }

fn sqrt(&self) -> Self

Returns the truncated principal square root of an integer – ⌊√x⌋

fn cbrt(&self) -> Self

Returns the truncated principal cube root of an integer – if x >= 0 { ⌊∛x⌋ } else { ⌈∛x⌉ }

impl<T: MachineWord, const N: usize, P: Personality> Saturating for FixedUInt<T, N, P>

Available on crate feature num-traits only.

Note: This is marked deprecated, but still used by PrimInt

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

Saturating addition operator. Returns a+b, saturating at the numeric bounds instead of overflowing.

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

Saturating subtraction operator. Returns a-b, saturating at the numeric bounds instead of overflowing.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SaturatingAdd for FixedUInt<T, N, P>

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

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SaturatingAdd for &FixedUInt<T, N, P>

fn saturating_add(self, other: Self) -> FixedUInt<T, N, P>

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<T: MachineWord, const N: usize, P: Personality> SaturatingAdd for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn saturating_add(&self, other: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SaturatingMul for FixedUInt<T, N, P>

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

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SaturatingMul for &FixedUInt<T, N, P>

fn saturating_mul(self, other: Self) -> FixedUInt<T, N, P>

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<T: MachineWord, const N: usize, P: Personality> SaturatingMul for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn saturating_mul(&self, other: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SaturatingSub for FixedUInt<T, N, P>

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

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SaturatingSub for &FixedUInt<T, N, P>

fn saturating_sub(self, other: Self) -> FixedUInt<T, N, P>

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<T: MachineWord, const N: usize, P: Personality> SaturatingSub for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn saturating_sub(&self, other: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<&u32> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: &u32) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<&u32> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: &u32) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<&usize> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: &usize) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<&usize> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: &usize) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<u32> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: u32) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<u32> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: u32) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<usize> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: usize) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shl<usize> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the << operator.

fn shl(self, bits: usize) -> Self::Output

Performs the << operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShlAssign<&usize> for FixedUInt<T, N, P>

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

Performs the <<= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShlAssign<usize> for FixedUInt<T, N, P>

fn shl_assign(&mut self, bits: usize)

Performs the <<= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShlExact for FixedUInt<T, N, P>

fn shl_exact(self, rhs: u32) -> Option<Self>

Exact shift left. Computes self << rhs if no bits would be shifted out (so the operation can be losslessly reversed), None otherwise.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShlExact for &FixedUInt<T, N, P>

fn shl_exact(self, rhs: u32) -> Option<FixedUInt<T, N, P>>

Exact shift left. Computes self << rhs if no bits would be shifted out (so the operation can be losslessly reversed), None otherwise.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<&u32> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: &u32) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<&u32> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: &u32) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<&usize> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: &usize) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<&usize> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: &usize) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<u32> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: u32) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<u32> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: u32) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<usize> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: usize) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Shr<usize> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the >> operator.

fn shr(self, bits: usize) -> Self::Output

Performs the >> operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShrAssign<&usize> for FixedUInt<T, N, P>

fn shr_assign(&mut self, bits: &usize)

Performs the >>= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShrAssign<usize> for FixedUInt<T, N, P>

fn shr_assign(&mut self, bits: usize)

Performs the >>= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShrExact for FixedUInt<T, N, P>

fn shr_exact(self, rhs: u32) -> Option<Self>

Exact shift right. Computes self >> rhs if no one-bits would be shifted out (so the operation can be losslessly reversed), None otherwise.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ShrExact for &FixedUInt<T, N, P>

fn shr_exact(self, rhs: u32) -> Option<FixedUInt<T, N, P>>

Exact shift right. Computes self >> rhs if no one-bits would be shifted out (so the operation can be losslessly reversed), None otherwise.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictAdd for FixedUInt<T, N, Nct>

fn strict_add(self, v: Self) -> Self

Strict addition. Computes self + v, panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictAdd for &FixedUInt<T, N, Nct>

fn strict_add(self, v: Self) -> FixedUInt<T, N, Nct>

Strict addition. Computes self + v, panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictDiv for FixedUInt<T, N, Nct>

fn strict_div(self, v: Self) -> Self

Strict division. Computes self / v, panicking on overflow (only possible for MIN / -1 on a signed type) or if v is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictDiv for &FixedUInt<T, N, Nct>

fn strict_div(self, v: Self) -> FixedUInt<T, N, Nct>

Strict division. Computes self / v, panicking on overflow (only possible for MIN / -1 on a signed type) or if v is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictMul for FixedUInt<T, N, Nct>

fn strict_mul(self, v: Self) -> Self

Strict multiplication. Computes self * v, panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictMul for &FixedUInt<T, N, Nct>

fn strict_mul(self, v: Self) -> FixedUInt<T, N, Nct>

Strict multiplication. Computes self * v, panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictPow for FixedUInt<T, N, Nct>

fn strict_pow(self, exp: u32) -> Self

Strict exponentiation. Computes self.pow(exp), panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictPow for &FixedUInt<T, N, Nct>

fn strict_pow(self, exp: u32) -> FixedUInt<T, N, Nct>

Strict exponentiation. Computes self.pow(exp), panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictRem for FixedUInt<T, N, Nct>

fn strict_rem(self, v: Self) -> Self

Strict remainder. Computes self % v, panicking on overflow (only possible for MIN % -1 on a signed type) or if v is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictRem for &FixedUInt<T, N, Nct>

fn strict_rem(self, v: Self) -> FixedUInt<T, N, Nct>

Strict remainder. Computes self % v, panicking on overflow (only possible for MIN % -1 on a signed type) or if v is zero.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictShl for FixedUInt<T, N, Nct>

fn strict_shl(self, rhs: u32) -> Self

Strict shift left. Computes self << rhs, panicking if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictShl for &FixedUInt<T, N, Nct>

fn strict_shl(self, rhs: u32) -> FixedUInt<T, N, Nct>

Strict shift left. Computes self << rhs, panicking if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictShr for FixedUInt<T, N, Nct>

fn strict_shr(self, rhs: u32) -> Self

Strict shift right. Computes self >> rhs, panicking if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictShr for &FixedUInt<T, N, Nct>

fn strict_shr(self, rhs: u32) -> FixedUInt<T, N, Nct>

Strict shift right. Computes self >> rhs, panicking if rhs is larger than or equal to the number of bits in self.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictSub for FixedUInt<T, N, Nct>

fn strict_sub(self, v: Self) -> Self

Strict subtraction. Computes self - v, panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize> StrictSub for &FixedUInt<T, N, Nct>

fn strict_sub(self, v: Self) -> FixedUInt<T, N, Nct>

Strict subtraction. Computes self - v, panicking on overflow regardless of whether overflow checks are enabled.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Sub for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Sub for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Sub<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the - operator.

fn sub(self, other: &Self) -> Self

Performs the - operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Sub<FixedUInt<T, N, P>> for &FixedUInt<T, N, P>

type Output = FixedUInt<T, N, P>

The resulting type after applying the - operator.

fn sub(self, other: FixedUInt<T, N, P>) -> Self::Output

Performs the - operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SubAssign for FixedUInt<T, N, P>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> SubAssign<&FixedUInt<T, N, P>> for FixedUInt<T, N, P>

fn sub_assign(&mut self, other: &Self)

Performs the -= operation.

impl<T: MachineWord, const N: usize, P: Personality> Sum for FixedUInt<T, N, P>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T: MachineWord, const N: usize, P: Personality> Sum<&'a FixedUInt<T, N, P>> for FixedUInt<T, N, P>

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T: MachineWord, const N: usize, P: Personality> ToPrimitive for FixedUInt<T, N, P>

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> UnboundedShl for FixedUInt<T, N, P>

fn unbounded_shl(self, rhs: u32) -> Self

Unbounded shift left. Computes self << rhs, without bounding the value of rhs: if rhs >= BITS the entire value is shifted out and 0 is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> UnboundedShl for &FixedUInt<T, N, P>

fn unbounded_shl(self, rhs: u32) -> FixedUInt<T, N, P>

Unbounded shift left. Computes self << rhs, without bounding the value of rhs: if rhs >= BITS the entire value is shifted out and 0 is returned.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> UnboundedShr for FixedUInt<T, N, P>

fn unbounded_shr(self, rhs: u32) -> Self

Unbounded shift right. Computes self >> rhs, without bounding the value of rhs: if rhs >= BITS, unsigned values become 0 and signed values become 0 or -1 depending on the sign (the sign bit fills every position).

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> UnboundedShr for &FixedUInt<T, N, P>

fn unbounded_shr(self, rhs: u32) -> FixedUInt<T, N, P>

Unbounded shift right. Computes self >> rhs, without bounding the value of rhs: if rhs >= BITS, unsigned values become 0 and signed values become 0 or -1 depending on the sign (the sign bit fills every position).

impl<T: MachineWord, const N: usize> Unsigned for FixedUInt<T, N, Nct>

Available on crate feature num-traits only.

impl<T: MachineWord, const N: usize> UpperHex for FixedUInt<T, N, Nct>

where u8: TryFrom<T>,

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

Formats the value using the given formatter.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingAdd for FixedUInt<T, N, P>

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

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingAdd for &FixedUInt<T, N, P>

fn wrapping_add(self, other: Self) -> FixedUInt<T, N, P>

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<T: MachineWord, const N: usize, P: Personality> WrappingAdd for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn wrapping_add(&self, other: &Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingMul for FixedUInt<T, N, P>

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

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingMul for &FixedUInt<T, N, P>

fn wrapping_mul(self, other: Self) -> FixedUInt<T, N, P>

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<T: MachineWord, const N: usize, P: Personality> WrappingMul for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn wrapping_mul(&self, other: &Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingShl for FixedUInt<T, N, P>

fn wrapping_shl(self, bits: u32) -> Self

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingShl for &FixedUInt<T, N, P>

fn wrapping_shl(self, bits: u32) -> FixedUInt<T, N, P>

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<T: MachineWord, const N: usize, P: Personality> WrappingShl for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn wrapping_shl(&self, bits: u32) -> Self

Panic-free bitwise shift-left; yields self << mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingShr for FixedUInt<T, N, P>

fn wrapping_shr(self, bits: u32) -> Self

Panic-free bitwise shift-right; yields self >> mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingShr for &FixedUInt<T, N, P>

fn wrapping_shr(self, bits: u32) -> FixedUInt<T, N, P>

Panic-free bitwise shift-right; yields self >> mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<T: MachineWord, const N: usize, P: Personality> WrappingShr for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn wrapping_shr(&self, bits: u32) -> Self

Panic-free bitwise shift-right; yields self >> mask(rhs), where mask removes any high order bits of rhs that would cause the shift to exceed the bitwidth of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingSub for FixedUInt<T, N, P>

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

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> WrappingSub for &FixedUInt<T, N, P>

fn wrapping_sub(self, other: Self) -> FixedUInt<T, N, P>

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<T: MachineWord, const N: usize, P: Personality> WrappingSub for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn wrapping_sub(&self, other: &Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> Zero for FixedUInt<T, N, P>

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T: MachineWord, const N: usize, P: Personality> Zero for FixedUInt<T, N, P>

Available on crate feature num-traits only.

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.