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.

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

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

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

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

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

Performs the * operation.

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

fn shl_assign(&mut self, bits: usize)

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

fn shr_assign(&mut self, bits: usize)

Performs the >>= operation.

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

Performs the - operation.

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