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 crate::personality.

Implementations

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 phase 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 ConstCheckedShl::checked_shl.

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

CT-friendly counterpart to ConstCheckedShr::checked_shr.

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

where T: ConstantTimeEq,

CT-friendly counterpart to ConstPowerOfTwo::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 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> 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> 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 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> 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> 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> 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> 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> 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<&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> 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> 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> 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> 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> BitXorAssign for FixedUInt<T, N, P>

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl<T: 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: ConstMachineWord + ConstCarryingAdd + ConstBorrowingSub + MachineWord, const N: usize, P: Personality> CarryingMul for &FixedUInt<T, N, P>

Ref-based carrying multiplication — allows calling with references.

type Output = FixedUInt<T, N, P>

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

Calculates self * rhs + carry, returning (low, high).

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

Calculates self * rhs + addend + carry, returning (low, high).

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

Non-const carrying multiplication that delegates to ConstCarryingMul.

type Output = FixedUInt<T, N, P>

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

Calculates self * rhs + carry, returning (low, high).

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

Calculates self * rhs + addend + carry, returning (low, high).

impl<T: 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: MachineWord, const N: usize> CheckedDiv for FixedUInt<T, N, Nct>

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: MachineWord, const N: usize> CheckedEuclid for FixedUInt<T, N, Nct>

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

Performs euclid division that returns None instead of panicking on division by zero and instead of wrapping around on underflow and overflow.

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

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

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

Returns both the quotient and remainder from checked Euclidean division.

impl<T: 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 underflow or overflow. If underflow or overflow happens, None is returned.

impl<T: 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 underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T: 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: 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: 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 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> ConstAbsDiff for FixedUInt<T, N, P>

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

Computes the absolute difference between self and other.

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

fn count_ones(self) -> u32

fn count_zeros(self) -> u32

fn leading_zeros(self) -> u32

fn trailing_zeros(self) -> u32

fn swap_bytes(self) -> Self

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

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

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

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

fn reverse_bits(self) -> Self

fn from_be(x: Self) -> Self

fn from_le(x: Self) -> Self

fn to_be(self) -> Self

fn to_le(self) -> Self

fn leading_ones(self) -> u32

fn trailing_ones(self) -> u32

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

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

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

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

Calculates self - rhs - borrow, returning (difference, borrow_out).

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

fn min_value() -> Self

Returns the smallest value of this type.

fn max_value() -> Self

Returns the largest value of this type.

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

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

Calculates self + rhs + carry, returning (sum, carry_out).

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

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

Calculates self * rhs + carry, returning (low, high).

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

Calculates self * rhs + addend + carry, returning (low, high).

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

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

Checked addition. Returns None if overflow occurred.

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

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

Checked division. Returns None if the divisor is zero.

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

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

Checked Euclidean division. Returns None if the divisor is zero.

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

Checked Euclidean remainder. Returns None if the divisor is zero.

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

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

Checked multiplication. Returns None if overflow occurred.

impl<T: ConstMachineWord + MachineWord, const N: usize> ConstCheckedPow 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> ConstCheckedRem for FixedUInt<T, N, Nct>

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

Checked remainder. Returns None if the divisor is zero.

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

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

Checked shift left. Returns None if the shift amount exceeds bit width.

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

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

Checked shift right. Returns None if the shift amount exceeds bit width.

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

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

Checked subtraction. Returns None if overflow occurred.

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

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

Calculates the quotient of self and rhs, rounding up.

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

Calculates the quotient of self and rhs, rounding up.

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

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

Euclidean division. For unsigned integers, same as regular division.

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

Euclidean remainder. For unsigned integers, same as regular remainder.

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

fn ilog2(self) -> u32

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

fn ilog10(self) -> u32

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

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

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

fn checked_ilog2(self) -> Option<u32>

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

fn checked_ilog10(self) -> Option<u32>

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

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

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

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

fn isqrt(self) -> Self

Returns the integer square root of self.

fn checked_isqrt(self) -> Option<Self>

Returns the integer square root of self.

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

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

Calculates the midpoint (average) of self and rhs, rounded down.

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

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

Returns true if self is a multiple of rhs.

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

Returns the smallest value greater than or equal to self that is a multiple of rhs.

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

Returns the smallest value greater than or equal to self that is a multiple of rhs.

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

fn one() -> Self

Returns the multiplicative identity (one).

fn is_one(&self) -> bool

Returns true if self is one.

fn set_one(&mut self)

Sets self to one.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ConstOverflowingAdd 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> ConstOverflowingMul 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> ConstOverflowingShl for FixedUInt<T, N, P>

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

Shift left with overflow detection. Returns the shifted value and whether the shift amount exceeded the bit width.

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

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

Shift right with overflow detection. Returns the shifted value and whether the shift amount exceeded the bit width.

impl<T: ConstMachineWord + MachineWord, const N: usize, P: Personality> ConstOverflowingSub 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> ConstPowerOfTwo for FixedUInt<T, N, P>

fn is_power_of_two(&self) -> bool

Returns true if self is a power of two.

fn next_power_of_two(self) -> Self

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

fn checked_next_power_of_two(self) -> Option<Self>

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

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

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

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

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

Saturating addition. Computes self + v, saturating at max_value().

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

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

Saturating multiplication. Computes self * v, saturating at max_value().

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

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

Saturating subtraction. Computes self - v, saturating at zero.

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

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

Unbounded shift left. Returns 0 if rhs is greater than or equal to the bit width of the type.

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

Unbounded shift right. Returns 0 if rhs is greater than or equal to the bit width of the type.

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

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

Calculates the complete product self * rhs without overflow.

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

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

Wrapping (modular) addition. Computes self + v, wrapping around at the boundary of the type.

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

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

Wrapping (modular) multiplication. Computes self * v, wrapping around at the boundary of the type.

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

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

Wrapping shift left. Shifts, masking the shift amount to the bit width.

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

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

Wrapping shift right. Shifts, masking the shift amount to the bit width.

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

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

Wrapping (modular) subtraction. Computes self - v, wrapping around at the boundary of the type.

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

fn zero() -> Self

Returns the additive identity (zero).

fn is_zero(&self) -> bool

Returns true if self is zero.

fn set_zero(&mut self)

Sets self to zero.

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: 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: 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<&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> 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> 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> DivAssign for FixedUInt<T, N, Nct>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T: 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, 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: 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: 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: 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: 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>

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: 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: 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> 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> 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, const N: usize> MulAccOps for FixedUInt<T, N, Nct>

where T: MachineWord + CarryingMul<Output = T> + ConstCarryingAdd,

type GetWordOutput = Option<T>

Return type of get_word: Option<Word> for Nct implementations, subtle::CtOption<Word> for Ct implementations. The discriminant shape encodes the call site’s CT contract — Option matches via Some/None (NCT-callable), CtOption exposes only subtle-backed methods (CT-callable).

type Word = T

The machine-word type used as a scalar in row operations.

fn get_word(&self, i: usize) -> Option<T>

Access the i-th word (little-endian, i = 0 is least significant). Returns the personality-appropriate “maybe-a-word” type: Option<Self::Word> for NCT impls (O(1) fast path), subtle::CtOption<Self::Word> for CT impls (O(N) constant-time scan).

fn word_count() -> usize

Number of words in this type.

fn mul_acc_row(scalar: T, multiplicand: &Self, acc: &mut Self, carry_in: T) -> T

Phase 1 row: acc += scalar * multiplicand

fn mul_acc_shift_row( scalar: T, multiplicand: &Self, acc: &mut Self, acc_hi: T, ) -> T

Phase 2 row: [acc, acc_hi] = ([acc, acc_hi] + scalar * multiplicand) >> word_bits

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

where T: MachineWord + CarryingMul<Output = T> + ConstCarryingAdd + ConditionallySelectable,

type GetWordOutput = CtOption<T>

Return type of get_word: Option<Word> for Nct implementations, subtle::CtOption<Word> for Ct implementations. The discriminant shape encodes the call site’s CT contract — Option matches via Some/None (NCT-callable), CtOption exposes only subtle-backed methods (CT-callable).

type Word = T

The machine-word type used as a scalar in row operations.

fn get_word(&self, i: usize) -> CtOption<T>

Access the i-th word (little-endian, i = 0 is least significant). Returns the personality-appropriate “maybe-a-word” type: Option<Self::Word> for NCT impls (O(1) fast path), subtle::CtOption<Self::Word> for CT impls (O(N) constant-time scan).

fn word_count() -> usize

Number of words in this type.

fn mul_acc_row(scalar: T, multiplicand: &Self, acc: &mut Self, carry_in: T) -> T

Phase 1 row: acc += scalar * multiplicand

fn mul_acc_shift_row( scalar: T, multiplicand: &Self, acc: &mut Self, acc_hi: T, ) -> T

Phase 2 row: [acc, acc_hi] = ([acc, acc_hi] + scalar * multiplicand) >> word_bits

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

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: MachineWord, const N: usize, P: Personality> One for FixedUInt<T, N, P>

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: 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: 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: MachineWord, const N: usize, P: Personality> OverflowingShl for FixedUInt<T, N, P>

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

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

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

impl<T: 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> 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: MachineWord, const N: usize> PrimInt for FixedUInt<T, N, Nct>

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<'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: 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<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> 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> RemAssign<&FixedUInt<T, N>> for FixedUInt<T, N, Nct>

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

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

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: 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: 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: 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> 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> 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> 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> 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 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> SubAssign<&FixedUInt<T, N, P>> 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 for FixedUInt<T, N, P>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

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> 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<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: 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 + ConstCarryingAdd + ConstBorrowingSub + MachineWord, const N: usize, P: Personality> WideningMul for &FixedUInt<T, N, P>

Ref-based widening multiplication — allows calling with references.

type Output = FixedUInt<T, N, P>

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

Calculates the complete product self * rhs without overflow.

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

Non-const widening multiplication that delegates to ConstWideningMul.

type Output = FixedUInt<T, N, P>

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

Calculates the complete product self * rhs without overflow.

impl<T: 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: 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: 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: 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: 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: 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, const N: usize, P: Copy + Personality> Copy for FixedUInt<T, N, P>

where T: MachineWord + Copy,

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

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