Struct HeaplessBigInt 

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

A len-word unsigned integer whose width is chosen at runtime.

Behaves bit-for-bit like FixedUInt<T, len>: every op resolves at the value’s width (len·word_bits), never a growable bignum. CAP is the maximum limb count (compile-time storage ceiling); len is the logical used-limb count (runtime) and the operating width — the words in [len, CAP) do not exist for arithmetic. Invariants (enforced by the module):

• CAP <= u16::MAX as usize (compile-time-asserted).
• (len as usize) <= CAP.
• limbs[len as usize..CAP] is all zero at every observable state.
• len is set only from public shape parameters, never from limb content.

Implementations

impl<T: MachineWord, const CAP: usize, P: Personality> HeaplessBigInt<T, CAP, P>

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

Wrapping addition at the operands’ width max(a.len, b.len); a carry out of that width is discarded.

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

Overflowing addition, at the operands’ width max(a.len, b.len). Returns (sum mod 2^(width·word_bits), carry_out) — the carry is the bit beyond the width, reported as a flag, exactly as FixedUInt<T, width>::overflowing_add does. Symmetric to overflowing_sub. Does not grow a limb.

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

Checked addition. None on overflow at the operands’ width.

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

Wrapping subtraction at the operands’ width max(a.len, b.len); underflow wraps modulo 2^(max_len·WORD_BITS), so a value carried at a narrower width wraps at that narrower width (like u8 vs u32).

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

Overflowing subtraction. Returns (wrapped_result, borrow_out). Same width choice as wrapping_sub; borrow_out is the underflow flag (self < other).

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

Checked subtraction. None on underflow.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> HeaplessBigInt<T, CAP, P>

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

Wrapping multiplication at the operands’ width max(a.len, b.len): keeps the low width words (a·b mod 2^(width·word_bits)), exactly like FixedUInt<T, width>::wrapping_mul. [WideMul] returns both halves.

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

Overflowing multiplication, at the operands’ width w = max(a.len, b.len). Returns (a·b mod 2^(w·word_bits), overflow), where overflow is set iff the product does not fit in w words — bit-identical to FixedUInt<T, w>::overflowing_mul. The split is at the value width (via the widening CarryingMul), so the high half is the part beyond w; CAP is irrelevant.

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

Checked multiplication. None when the product does not fit in the operands’ width max(a.len, b.len) — exactly when FixedUInt<T, width>::checked_mul would return None.

impl<T: MachineWord, const CAP: usize> HeaplessBigInt<T, CAP, Nct>

pub fn trim(self) -> Self

Trim len down to the highest non-zero limb + 1 (0 for zero). NCT-implicit — inspects limb content, so Nct-only.

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

Saturating addition: on overflow, the all-ones value at the operands’ width max(a.len, b.len) (not the CAP-wide max), matching FixedUInt<T, width>::saturating_add. This inherent form branches on the overflow flag; the Ct carrier’s branchless SaturatingAdd impl (via ct_select) is defined separately.

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

Saturating subtraction: clamps to zero at the operands’ width on underflow. Nct-only, same reason as saturating_add.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize> HeaplessBigInt<T, CAP, Nct>

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

Saturating multiplication: on overflow, the all-ones value at the operands’ width max(a.len, b.len). Nct-only, same reason as saturating_add.

impl<T: MachineWord, const CAP: usize, P: Personality> HeaplessBigInt<T, CAP, P>

pub fn bit_length(&self) -> usize

Number of bits needed to represent the value: 0 for zero, otherwise the position of the highest set bit plus one.

pub fn leading_zeros(&self) -> usize

Leading zeros against the value’s width (len * word_bits), so leading_zeros + bit_length == bits_precision(). A len = 0 value has width 0, hence leading_zeros() == 0.

impl<T: MachineWord, const CAP: usize, P: Personality> HeaplessBigInt<T, CAP, P>

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

Serialize into out as big-endian bytes. Writes self.len * size_of::<T>() bytes into out[..byte_count] and returns that slice. Panics if out.len() < byte_count.

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

Serialize into out as little-endian bytes. Same size + panic contract as to_be_bytes.

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

Deserialize a big-endian byte slice. Output len = ceil(bytes.len() / word_size), capped at CAP. A partial top word (input length not a multiple of word_size) leaves the missing high bytes zero — matches the BE convention. Panics if bytes.len() > CAP * word_size.

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

Deserialize a little-endian byte slice. Same size contract as from_be_bytes.

impl<T, const CAP: usize> HeaplessBigInt<T, CAP, Nct>

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

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

Quotient and remainder in one pass. Panics on divide-by-zero, like the Div/Rem operators; use checked_div/checked_rem to avoid the panic.

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

Checked division. None on divide-by-zero.

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

Checked remainder. None on divide-by-zero.

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

Ceiling division. None on divide-by-zero or when rounding up overflows the value width. Result width is max(self.len, other.len).

impl<T, const CAP: usize> HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

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

Unsigned isqrt cannot fail; always Some. Parallels FixedUInt::checked_isqrt and the signed-only external CheckedIsqrt.

impl<T, const CAP: usize> HeaplessBigInt<T, CAP, Nct>

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

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

Raises self to exp by squaring. Panics on overflow at the value width (Nct), like std’s pow; use checked_pow to get None instead.

impl<T: MachineWord, const CAP: usize, P: Personality> HeaplessBigInt<T, CAP, P>

pub fn new_zero_with_len(len: u16) -> Self

Zero with a caller-supplied logical length. The len is treated as a public shape parameter from here on. Panics if len > CAP.

pub fn zero_full_cap() -> Self

Full-capacity zero: len = CAP. Used where an algorithm needs a pre-sized workspace (CIOS accumulator, product buffer).

pub fn from_limbs(limbs: [T; CAP], len: u16) -> Self

Construct from a limb array + explicit len. Panics if len > CAP or if any limb at index >= len is non-zero (invariant check).

The tail check runs in every build, not just under debug_assertions: downstream arithmetic, equality, and widened all assume the tail is zero, so a release build that skipped it would silently promote a hidden limb into the value.

impl<T: MachineWord, const CAP: usize, P: Personality> HeaplessBigInt<T, CAP, P>

pub const fn len(&self) -> u16

Logical length in used limbs. Public shape parameter.

pub const fn is_empty(&self) -> bool

True iff len == 0 (mathematical zero shape).

pub const fn capacity(&self) -> usize

Maximum limb count.

pub fn widened(&self, new_len: u16) -> Self

Return a copy carried at new_len words, pinning the operating width without changing the value.

Arithmetic here is width-driven: a HeaplessBigInt at len = k behaves exactly like FixedUInt<T, k>, and every op resolves at max(operand len). So a value assembled from small pieces (e.g. an accumulator seeded from zero then added to a one-word digit) is a narrow type and wraps at that narrow width. To carry it at a chosen width — the way you pick N for FixedUInt — pin it here once; subsequent ops keep that width because max preserves it. Widening only relabels the width: the limbs in [len, new_len) are already zero by the zero-tail invariant.

Panics if new_len < len (this only widens) or new_len > CAP.

pub fn limbs(&self) -> &[T]

Read-only view of the used limbs.

pub fn all_limbs(&self) -> &[T; CAP]

Full-buffer view including the zero tail. Only meaningful under the zero-tail invariant.

Trait Implementations

impl<T, const CAP: usize> AbsDiff for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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, const CAP: usize> AbsDiff for HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

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, const CAP: usize> AbsDiff for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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

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

impl<T, const CAP: usize> AbsDiff for &HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

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

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

impl<T: MachineWord, const CAP: usize, P: Personality> Add for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Add<&HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the + operator.

fn add(self, other: &HeaplessBigInt<T, CAP, P>) -> Self::Output

Performs the + operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Add<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Add<HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the + operator.

fn add(self, other: HeaplessBigInt<T, CAP, P>) -> HeaplessBigInt<T, CAP, P>

Performs the + operation.

impl<T: MachineWord, const CAP: usize, P: Personality> AddAssign for HeaplessBigInt<T, CAP, P>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T: MachineWord, const CAP: usize, P: Personality> AddAssign<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

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

Performs the += operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitAnd for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitAnd<&HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitAnd<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitAnd<HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the & operator.

fn bitand(self, other: HeaplessBigInt<T, CAP, P>) -> HeaplessBigInt<T, CAP, P>

Performs the & operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitAndAssign for HeaplessBigInt<T, CAP, P>

fn bitand_assign(&mut self, other: Self)

Performs the &= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitAndAssign<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

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

Performs the &= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitOr for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitOr<&HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitOr<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitOr<HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the | operator.

fn bitor(self, other: HeaplessBigInt<T, CAP, P>) -> HeaplessBigInt<T, CAP, P>

Performs the | operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitOrAssign for HeaplessBigInt<T, CAP, P>

fn bitor_assign(&mut self, other: Self)

Performs the |= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitOrAssign<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

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

Performs the |= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitWidth for HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> BitWidth for &HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> BitXor for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitXor<&HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitXor<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitXor<HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the ^ operator.

fn bitxor(self, other: HeaplessBigInt<T, CAP, P>) -> HeaplessBigInt<T, CAP, P>

Performs the ^ operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitXorAssign for HeaplessBigInt<T, CAP, P>

fn bitxor_assign(&mut self, other: Self)

Performs the ^= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitXorAssign<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

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

Performs the ^= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> BitsPrecision for HeaplessBigInt<T, CAP, P>

fn bits_precision(&self) -> u32

The number of bits self operates over (its constructed width).

impl<T: MachineWord, const CAP: usize, P: Personality> BitsPrecision for &HeaplessBigInt<T, CAP, P>

fn bits_precision(&self) -> u32

The number of bits self operates over (its constructed width).

impl<T, const CAP: usize, P: Personality> BorrowingSub for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, P>

The difference type (Self for the primitive impls).

fn borrowing_sub(self, rhs: Self, borrow_in: bool) -> (Self::Output, 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, const CAP: usize, P: Personality> BorrowingSub for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, P>

The difference type (Self for the primitive impls).

fn borrowing_sub(self, rhs: Self, borrow_in: bool) -> (Self::Output, 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: MachineWord, const CAP: usize, P: Personality> Bounded for HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> Bounded for HeaplessBigInt<T, CAP, 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, const CAP: usize, P: Personality> CarryingAdd for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, P>

The sum type (Self for the primitive impls).

fn carrying_add(self, rhs: Self, carry_in: bool) -> (Self::Output, 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, const CAP: usize, P: Personality> CarryingAdd for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, P>

The sum type (Self for the primitive impls).

fn carrying_add(self, rhs: Self, carry_in: bool) -> (Self::Output, 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, const CAP: usize, P: Personality> CarryingMul for HeaplessBigInt<T, CAP, P>

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

type Unsigned = HeaplessBigInt<T, CAP, 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).

type Output = HeaplessBigInt<T, CAP, P>

The type of the high half of the result (Self for the primitive impls).

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

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, carry: Self, add: Self, ) -> (Self::Unsigned, Self::Output)

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

impl<T, const CAP: usize, P: Personality> CarryingMul for &HeaplessBigInt<T, CAP, P>

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

type Unsigned = HeaplessBigInt<T, CAP, 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).

type Output = HeaplessBigInt<T, CAP, P>

The type of the high half of the result (Self for the primitive impls).

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

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, carry: Self, add: Self, ) -> (Self::Unsigned, Self::Output)

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

impl<T, const CAP: usize> CheckedAdd for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type. Self for the primitive impls; a distinct owned type lets non-Copy types implement this via impl for &Self.

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

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

impl<T, const CAP: usize> CheckedAdd for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type. Self for the primitive impls; a distinct owned type lets non-Copy types implement this via impl for &Self.

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

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

impl<T, const CAP: usize> CheckedAdd for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

Available on crate feature num-traits only.

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

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

impl<T, const CAP: usize> CheckedDiv for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedDiv for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedDiv for HeaplessBigInt<T, CAP, Nct>

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

Available on crate feature num-traits only.

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

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

impl<T, const CAP: usize> CheckedEuclid for HeaplessBigInt<T, CAP, Nct>

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

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, const CAP: usize> CheckedEuclid for &HeaplessBigInt<T, CAP, Nct>

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

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

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

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

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 as Euclid>::Output, <Self as Euclid>::Output)>

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

impl<T, const CAP: usize> CheckedMul for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedMul for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedMul for HeaplessBigInt<T, CAP, Nct>

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

Available on crate feature num-traits only.

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

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

impl<T, const CAP: usize> CheckedPow for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedPow for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedRem for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

fn checked_rem(self, v: 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, const CAP: usize> CheckedRem for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedRem for HeaplessBigInt<T, CAP, Nct>

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

Available on crate feature num-traits only.

fn checked_rem(&self, v: &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 CAP: usize, P: Personality> CheckedShl for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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 CAP: usize, P: Personality> CheckedShl for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn checked_shl(self, bits: u32) -> Option<HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> CheckedShl for HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> CheckedShr for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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 CAP: usize, P: Personality> CheckedShr for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn checked_shr(self, bits: u32) -> Option<HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> CheckedShr for HeaplessBigInt<T, CAP, 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, const CAP: usize> CheckedSub for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedSub for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> CheckedSub for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

Available on crate feature num-traits only.

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

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

impl<T: MachineWord, const CAP: usize, P: Personality> Clone for HeaplessBigInt<T, CAP, 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, const CAP: usize, P: Personality> ConditionallySelectable for HeaplessBigInt<T, CAP, P>

where T: MachineWord + ConditionallySelectable,

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: MachineWord, const CAP: usize, P: Personality> ConstOne for HeaplessBigInt<T, CAP, P>

const ONE: Self

The multiplicative identity element of Self, 1.

impl<T: MachineWord, const CAP: usize, P: Personality> ConstZero for HeaplessBigInt<T, CAP, P>

const ZERO: Self

The additive identity element of Self, 0.

impl<T, const CAP: usize, P: Personality> ConstantTimeEq for HeaplessBigInt<T, CAP, P>

where T: MachineWord + ConstantTimeEq,

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, const CAP: usize, P: Personality> ConstantTimeGreater for HeaplessBigInt<T, CAP, P>

where T: MachineWord + ConstantTimeEq + ConstantTimeGreater,

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

Determine whether self > other.

impl<T, const CAP: usize, P: Personality> ConstantTimeLess for HeaplessBigInt<T, CAP, P>

where T: MachineWord + ConstantTimeEq + ConstantTimeGreater,

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

Determine whether self < other.

impl<T: MachineWord, const CAP: usize, P: Personality> Copy for HeaplessBigInt<T, CAP, P>

impl<T, const CAP: usize, P: Personality> CtCheckedAdd for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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

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

impl<T, const CAP: usize, P: Personality> CtCheckedMul for HeaplessBigInt<T, CAP, P>

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

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

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

impl<T, const CAP: usize, P: Personality> CtCheckedSub for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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

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

impl<T, const CAP: usize, P: Personality> CtIsPowerOfTwo for HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> CtIsZero for HeaplessBigInt<T, CAP, P>

where T: MachineWord + ConstantTimeEq,

fn ct_is_zero(&self) -> Choice

Returns a masked true if self is zero.

impl<T, const CAP: usize, P: Personality> CtNonZero for HeaplessBigInt<T, CAP, P>

where T: MachineWord + ConstantTimeEq,

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

None-masked when self == 0.

impl<T, const CAP: usize, P: Personality> CtParity for HeaplessBigInt<T, CAP, P>

where T: MachineWord + ConstantTimeEq,

fn ct_is_odd(&self) -> Choice

Returns a masked true if self is odd.

fn ct_is_even(&self) -> Choice

Returns a masked true if self is even.

impl<T: MachineWord + Debug, const CAP: usize> Debug for HeaplessBigInt<T, CAP, Nct>

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

Formats the value using the given formatter.

impl<T: MachineWord, const CAP: usize> Debug for HeaplessBigInt<T, CAP, Ct>

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

Formats the value using the given formatter.

impl<T: MachineWord, const CAP: usize, P: Personality> Default for HeaplessBigInt<T, CAP, P>

fn default() -> Self

Returns the “default value” for a type.

impl<T, const CAP: usize> DepositBits for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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, const CAP: usize> DepositBits for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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) -> HeaplessBigInt<T, CAP, Nct>

impl<T, const CAP: usize> Display for HeaplessBigInt<T, CAP, Nct>

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

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

Formats the value using the given formatter.

impl<T, const CAP: usize> Div for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the / operator.

fn div(self, other: HeaplessBigInt<T, CAP, Nct>) -> Self::Output

Performs the / operation.

impl<T, const CAP: usize> Div<&HeaplessBigInt<T, CAP>> for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const CAP: usize> Div<&HeaplessBigInt<T, CAP>> for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, const CAP: usize> Div<HeaplessBigInt<T, CAP>> for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the / operator.

fn div(self, other: HeaplessBigInt<T, CAP, Nct>) -> Self::Output

Performs the / operation.

impl<T, const CAP: usize> DivAssign for HeaplessBigInt<T, CAP, Nct>

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

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<T, const CAP: usize> DivAssign<&HeaplessBigInt<T, CAP>> for HeaplessBigInt<T, CAP, Nct>

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

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

Performs the /= operation.

impl<T, const CAP: usize> DivCeil for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The quotient type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> DivCeil for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The quotient type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> DivNonZero for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

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: MachineWord, const CAP: usize, P: Personality> Eq for HeaplessBigInt<T, CAP, P>

impl<T, const CAP: usize> Euclid for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type of Euclidean division and remainder (Self for the primitive and float impls).

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 CAP: usize> Euclid for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type of Euclidean division and remainder (Self for the primitive and float impls).

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

Calculates Euclidean division, the matching method for rem_euclid.

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

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

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

Returns both the quotient and remainder from Euclidean division.

impl<T, const CAP: usize> ExtractBits for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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, const CAP: usize> ExtractBits for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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) -> HeaplessBigInt<T, CAP, Nct>

impl<T: MachineWord, const CAP: usize, P: Personality> From<u8> for HeaplessBigInt<T, CAP, P>

fn from(v: u8) -> Self

Converts to this type from the input type.

impl<T: MachineWord, const CAP: usize, P: Personality> From<u16> for HeaplessBigInt<T, CAP, P>

fn from(v: u16) -> Self

Converts to this type from the input type.

impl<T: MachineWord, const CAP: usize, P: Personality> From<u32> for HeaplessBigInt<T, CAP, P>

fn from(v: u32) -> Self

Converts to this type from the input type.

impl<T: MachineWord, const CAP: usize, P: Personality> From<u64> for HeaplessBigInt<T, CAP, P>

fn from(v: u64) -> Self

Converts to this type from the input type.

impl<T: MachineWord, const CAP: usize, P: Personality> FromByteSlice for HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> FromPrimitive for HeaplessBigInt<T, CAP, 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, const CAP: usize> FromStr for HeaplessBigInt<T, CAP, Nct>

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

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: MachineWord, const CAP: usize, P: Personality> FunnelShl for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> FunnelShl for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, 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) -> HeaplessBigInt<T, CAP, P>

impl<T: MachineWord, const CAP: usize, P: Personality> FunnelShr for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> FunnelShr for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, 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) -> HeaplessBigInt<T, CAP, P>

impl<T, const CAP: usize, P: Personality> HasNonZero for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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

Option is branchful at the call site — fine for public inputs; a secret-derived self should route through CtNonZero::into_nonzero_ct instead.

type NonZero = NonZeroHeaplessBigInt<T, CAP, P>

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

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

Recover the underlying value from its non-zero form.

impl<T: MachineWord, const CAP: usize, P: Personality> HasPersonality for HeaplessBigInt<T, CAP, P>

type P = P

The carrier’s personality.

impl<T: MachineWord + Hash, const CAP: usize, P: Personality> Hash for HeaplessBigInt<T, CAP, P>

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, const CAP: usize, P: Personality> HighestOne for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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, const CAP: usize, P: Personality> HighestOne for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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, const CAP: usize> Ilog for HeaplessBigInt<T, CAP, Nct>

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

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, const CAP: usize> Ilog for &HeaplessBigInt<T, CAP, Nct>

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

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, const CAP: usize> Ilog2 for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

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, const CAP: usize> Ilog2 for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

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, const CAP: usize> Ilog10 for HeaplessBigInt<T, CAP, Nct>

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

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, const CAP: usize> Ilog10 for &HeaplessBigInt<T, CAP, Nct>

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

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, const CAP: usize> Integer for HeaplessBigInt<T, CAP, Nct>

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

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 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 divides(&self, other: &Self) -> bool

👎Deprecated:

Please use is_multiple_of instead

Deprecated, use is_multiple_of instead.

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, const CAP: usize, P: Personality> IsPowerOfTwo for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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, const CAP: usize, P: Personality> IsPowerOfTwo for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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, const CAP: usize, P: Personality> IsolateHighestOne for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, 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, const CAP: usize, P: Personality> IsolateHighestOne for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, P>

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

fn isolate_highest_one(self) -> HeaplessBigInt<T, CAP, P>

impl<T, const CAP: usize, P: Personality> IsolateLowestOne for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, 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, const CAP: usize, P: Personality> IsolateLowestOne for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, P>

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

fn isolate_lowest_one(self) -> HeaplessBigInt<T, CAP, P>

impl<T, const CAP: usize> Isqrt for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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

fn isqrt(self) -> Self

impl<T, const CAP: usize> Isqrt for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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

fn isqrt(self) -> Self::Output

impl<T, const CAP: usize> LowerHex for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

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

Formats the value using the given formatter.

impl<T, const CAP: usize, P: Personality> LowestOne for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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, const CAP: usize, P: Personality> LowestOne for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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, const CAP: usize, P: Personality> Midpoint for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, 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, const CAP: usize, P: Personality> Midpoint for &HeaplessBigInt<T, CAP, P>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP, 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::Output

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> Mul for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> Mul<&HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> Mul<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> Mul<HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the * operator.

fn mul(self, other: HeaplessBigInt<T, CAP, P>) -> HeaplessBigInt<T, CAP, P>

Performs the * operation.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> MulAssign for HeaplessBigInt<T, CAP, P>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> MulAssign<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

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

Performs the *= operation.

impl<T, const CAP: usize> MultipleOf for HeaplessBigInt<T, CAP, Nct>

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

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

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

impl<T, const CAP: usize> MultipleOf for &HeaplessBigInt<T, CAP, Nct>

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

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

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

impl<T, const CAP: usize> NextMultipleOf for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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, const CAP: usize> NextMultipleOf for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

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, const CAP: usize> NextPowerOfTwo for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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, const CAP: usize> NextPowerOfTwo for HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

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

fn next_power_of_two(self) -> 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 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, const CAP: usize> NextPowerOfTwo for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

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

fn wrapping_next_power_of_two(self) -> Self::Output

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

fn checked_next_power_of_two(self) -> Option<Self::Output>

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

impl<T, const CAP: usize> NextPowerOfTwo for &HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

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

fn next_power_of_two(self) -> Self::Output

fn wrapping_next_power_of_two(self) -> Self::Output

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 checked_next_power_of_two(self) -> Option<Self::Output>

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

impl<T: MachineWord, const CAP: usize, P: Personality> Not for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Not for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const CAP: usize> Num for HeaplessBigInt<T, CAP, Nct>

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

Available on crate feature num-traits only.

type FromStrRadixErr = ParseIntError

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

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

impl<T: MachineWord, const CAP: usize, P: Personality> NumCast for HeaplessBigInt<T, CAP, P>

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

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 CAP: usize, P: Personality> One for HeaplessBigInt<T, CAP, 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

Returns true if self is equal to the multiplicative identity.

impl<T: MachineWord + CarryingMul<Unsigned = T, Output = T>, const CAP: usize, P: Personality> One for HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> Ord for HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> OverflowingAdd for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_add(self, v: Self) -> (Self::Output, 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 CAP: usize, P: Personality> OverflowingAdd for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_add(self, v: Self) -> (Self::Output, 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, const CAP: usize, P: Personality> OverflowingMul for HeaplessBigInt<T, CAP, P>

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

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_mul(self, v: Self) -> (Self::Output, 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, const CAP: usize, P: Personality> OverflowingMul for &HeaplessBigInt<T, CAP, P>

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

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_mul(self, v: Self) -> (Self::Output, 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 CAP: usize, P: Personality> OverflowingShl for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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: MachineWord, const CAP: usize, P: Personality> OverflowingShl for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_shl(self, bits: u32) -> (HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> OverflowingShr for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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: MachineWord, const CAP: usize, P: Personality> OverflowingShr for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_shr(self, bits: u32) -> (HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> OverflowingSub for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_sub(self, v: Self) -> (Self::Output, 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 CAP: usize, P: Personality> OverflowingSub for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn overflowing_sub(self, v: Self) -> (Self::Output, 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, const CAP: usize, P: Personality> Parity for HeaplessBigInt<T, CAP, P>

where T: MachineWord + Parity,

fn is_odd(self) -> bool

Returns true if self is odd.

fn is_even(self) -> bool

Returns true if self is even.

impl<T: MachineWord, const CAP: usize, P: Personality> PartialEq for HeaplessBigInt<T, CAP, P>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: MachineWord, const CAP: usize, P: Personality> PartialOrd for HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> PrimBits for HeaplessBigInt<T, CAP, 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 reverse_bits(self) -> Self

Reverses the order of bits in 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 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, const CAP: usize> PrimInt for HeaplessBigInt<T, CAP, Nct>

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

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, 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 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 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 swap_bytes(self) -> Self

Reverses the byte order of the integer.

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

impl<T, const CAP: usize, P: Personality> Product for HeaplessBigInt<T, CAP, P>

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

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, const CAP: usize, P: Personality> Product<&'a HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

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

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, const CAP: usize> Rem for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the % operator.

fn rem(self, other: HeaplessBigInt<T, CAP, Nct>) -> Self::Output

Performs the % operation.

impl<T, const CAP: usize> Rem<&HeaplessBigInt<T, CAP>> for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const CAP: usize> Rem<&HeaplessBigInt<T, CAP>> for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const CAP: usize> Rem<HeaplessBigInt<T, CAP>> for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The resulting type after applying the % operator.

fn rem(self, other: HeaplessBigInt<T, CAP, Nct>) -> Self::Output

Performs the % operation.

impl<T, const CAP: usize> RemAssign for HeaplessBigInt<T, CAP, Nct>

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

fn rem_assign(&mut self, other: Self)

Performs the %= operation.

impl<T, const CAP: usize> RemAssign<&HeaplessBigInt<T, CAP>> for HeaplessBigInt<T, CAP, Nct>

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

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

Performs the %= operation.

impl<T, const CAP: usize> Roots for HeaplessBigInt<T, CAP, Nct>

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

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, const CAP: usize> Saturating for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

Available on crate feature num-traits only.

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

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

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

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

impl<T, const CAP: usize> SaturatingAdd for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> SaturatingAdd for HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> SaturatingAdd for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

fn saturating_add(self, v: Self) -> Self::Output

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

impl<T, const CAP: usize> SaturatingAdd for &HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

The result type (Self for the primitive impls).

fn saturating_add(self, v: Self) -> Self::Output

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

impl<T, const CAP: usize> SaturatingMul for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> SaturatingMul for HeaplessBigInt<T, CAP, Ct>

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

type Output = HeaplessBigInt<T, CAP, Ct>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> SaturatingMul for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

fn saturating_mul(self, v: Self) -> Self::Output

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

impl<T, const CAP: usize> SaturatingMul for &HeaplessBigInt<T, CAP, Ct>

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

type Output = HeaplessBigInt<T, CAP, Ct>

The result type (Self for the primitive impls).

fn saturating_mul(self, v: Self) -> Self::Output

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

impl<T, const CAP: usize> SaturatingSub for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> SaturatingSub for HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> SaturatingSub for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

fn saturating_sub(self, v: Self) -> Self::Output

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

impl<T, const CAP: usize> SaturatingSub for &HeaplessBigInt<T, CAP, Ct>

where T: MachineWord + ConditionallySelectable,

type Output = HeaplessBigInt<T, CAP, Ct>

The result type (Self for the primitive impls).

fn saturating_sub(self, v: Self) -> Self::Output

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

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<&u32> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<&u32> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<&usize> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<&usize> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<u32> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<u32> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<usize> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shl<usize> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShlAssign<&u32> for HeaplessBigInt<T, CAP, P>

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

Performs the <<= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShlAssign<&usize> for HeaplessBigInt<T, CAP, P>

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

Performs the <<= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShlAssign<u32> for HeaplessBigInt<T, CAP, P>

fn shl_assign(&mut self, bits: u32)

Performs the <<= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShlAssign<usize> for HeaplessBigInt<T, CAP, P>

fn shl_assign(&mut self, bits: usize)

Performs the <<= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShlExact for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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: MachineWord, const CAP: usize, P: Personality> ShlExact for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn shl_exact(self, rhs: u32) -> Option<HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> Shr<&u32> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shr<&u32> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shr<&usize> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shr<&usize> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shr<u32> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shr<u32> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shr<usize> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Shr<usize> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShrAssign<&u32> for HeaplessBigInt<T, CAP, P>

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

Performs the >>= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShrAssign<&usize> for HeaplessBigInt<T, CAP, P>

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

Performs the >>= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShrAssign<u32> for HeaplessBigInt<T, CAP, P>

fn shr_assign(&mut self, bits: u32)

Performs the >>= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShrAssign<usize> for HeaplessBigInt<T, CAP, P>

fn shr_assign(&mut self, bits: usize)

Performs the >>= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> ShrExact for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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: MachineWord, const CAP: usize, P: Personality> ShrExact for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn shr_exact(self, rhs: u32) -> Option<HeaplessBigInt<T, CAP, 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, const CAP: usize> StrictAdd for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictAdd for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictDiv for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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, const CAP: usize> StrictDiv for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictMul for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictMul for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictPow for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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, const CAP: usize> StrictPow for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictRem for HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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, const CAP: usize> StrictRem for &HeaplessBigInt<T, CAP, Nct>

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

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictShl for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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, const CAP: usize> StrictShl for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictShr for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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, const CAP: usize> StrictShr for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictSub for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T, const CAP: usize> StrictSub for &HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

type Output = HeaplessBigInt<T, CAP>

The result type (Self for the primitive impls).

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

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

impl<T: MachineWord, const CAP: usize, P: Personality> Sub for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Sub<&HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the - operator.

fn sub(self, other: &HeaplessBigInt<T, CAP, P>) -> Self::Output

Performs the - operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Sub<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: MachineWord, const CAP: usize, P: Personality> Sub<HeaplessBigInt<T, CAP, P>> for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The resulting type after applying the - operator.

fn sub(self, other: HeaplessBigInt<T, CAP, P>) -> HeaplessBigInt<T, CAP, P>

Performs the - operation.

impl<T: MachineWord, const CAP: usize, P: Personality> SubAssign for HeaplessBigInt<T, CAP, P>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T: MachineWord, const CAP: usize, P: Personality> SubAssign<&HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

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

Performs the -= operation.

impl<T, const CAP: usize, P: Personality> Sum for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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, const CAP: usize, P: Personality> Sum<&'a HeaplessBigInt<T, CAP, P>> for HeaplessBigInt<T, CAP, P>

where T: MachineWord,

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 CAP: usize, P: Personality> ToPrimitive for HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> UnboundedShl for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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: MachineWord, const CAP: usize, P: Personality> UnboundedShl for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn unbounded_shl(self, rhs: u32) -> HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> UnboundedShr for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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: MachineWord, const CAP: usize, P: Personality> UnboundedShr for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn unbounded_shr(self, rhs: u32) -> HeaplessBigInt<T, CAP, 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, const CAP: usize> Unsigned for HeaplessBigInt<T, CAP, Nct>

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

impl<T, const CAP: usize> UpperHex for HeaplessBigInt<T, CAP, Nct>

where T: MachineWord,

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

Formats the value using the given formatter.

impl<T: MachineWord, const CAP: usize, P: Personality> WithPrecision for HeaplessBigInt<T, CAP, P>

fn widen_to_precision(self, bits_precision: u32) -> Self

Returns self re-represented over a width of at least bits_precision, preserving its numeric value. Never shrinks; on a fixed-width carrier the width is the type and this is the identity.

fn zero_with_precision(bits_precision: u32) -> Self

where Self: Zero,

A Zero carried at a width of at least bits_precision.

fn one_with_precision(bits_precision: u32) -> Self

where Self: One,

A One carried at a width of at least bits_precision.

fn widen_to_precision_of(self, witness: &Self) -> Self

widen_to_precision to the width of a witness value — typically the modulus a reducer operates over. Prefer this to hand-picking a bit count: the witness carries the intended width.

fn zero_with_precision_of(witness: &Self) -> Self

where Self: Zero,

A Zero carried at the witness’s width — the width-safe seed for a generic accumulator.

fn one_with_precision_of(witness: &Self) -> Self

where Self: One,

A One carried at the witness’s width.

impl<T: MachineWord, const CAP: usize, P: Personality> WrappingAdd for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_add(self, v: Self) -> Self::Output

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

impl<T: MachineWord, const CAP: usize, P: Personality> WrappingAdd for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_add(self, v: Self) -> Self::Output

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

impl<T, const CAP: usize, P: Personality> WrappingMul for HeaplessBigInt<T, CAP, P>

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

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_mul(self, v: Self) -> Self::Output

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

impl<T, const CAP: usize, P: Personality> WrappingMul for &HeaplessBigInt<T, CAP, P>

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

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_mul(self, v: Self) -> Self::Output

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

impl<T: MachineWord, const CAP: usize, P: Personality> WrappingShl for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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 CAP: usize, P: Personality> WrappingShl for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_shl(self, bits: u32) -> HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> WrappingShl for HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> WrappingShr for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

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 CAP: usize, P: Personality> WrappingShr for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_shr(self, bits: u32) -> HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> WrappingShr for HeaplessBigInt<T, CAP, 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: MachineWord, const CAP: usize, P: Personality> WrappingSub for HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_sub(self, v: Self) -> Self::Output

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

impl<T: MachineWord, const CAP: usize, P: Personality> WrappingSub for &HeaplessBigInt<T, CAP, P>

type Output = HeaplessBigInt<T, CAP, P>

The result type (Self for the primitive impls).

fn wrapping_sub(self, v: Self) -> Self::Output

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

impl<T: MachineWord, const CAP: usize, P: Personality> Zero for HeaplessBigInt<T, CAP, 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 CAP: usize, P: Personality> Zero for HeaplessBigInt<T, CAP, 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.