Struct Tight

pub struct Tight<const BASE: usize> { /* private fields */ }

A tightly-packed arbitrary base big int implementation. Supports any base from 2-u64::MAX.

In this implementation, bits are tightly packed against one another, requiring only ceil(log_2(BASE)) bits per digit. Signficiantly more space-efficient for smaller bases compared to the loose implementation. However, the extra indirection contributes to some added overhead.

use big_int::prelude::*;

let a: Tight<10> = 593.into();
let b = a * 96.into();
assert_eq!(b, 56928.into());

Implementations

impl<const BASE: usize> Tight<BASE>

pub unsafe fn from_raw_parts( data: VecDeque<Datum>, start_offset: usize, end_offset: usize, ) -> Self

Construct a Tight int directly from raw parts.

Ensure the following invariants hold true to maintain soundness:

• start_offset <= end_offset
• end_offset <= data.len() * big_int::tight::DATUM_SIZE
• (end_offset - start_offset) % Tight::<BASE>::BITS_PER_DIGIT == 0

use big_int::prelude::*;

let a: Tight<10> = unsafe { Tight::from_raw_parts(
    vec![0b0001_1001, 0b0101_0000].into(),
    0, 16
) };

assert_eq!(a, 1950.into());

pub fn aligned(self) -> Self

Return the int with the bits within aligned to the beginning of the data segment and unnecessary extra data truncated.

It’s likely unnecessary to invoke this directly unless using Tight::from_raw_parts.

use big_int::prelude::*;

let mut a: Tight<10> = unsafe { Tight::from_raw_parts(
    vec![0b0000_0000, 0b0000_1001, 0b0101_0000, 0b0000_0000].into(),
    12, 20
) };
assert_eq!(a.aligned(), unsafe { Tight::from_raw_parts(
    vec![0b1001_0101].into(),
    0, 8
) });

Trait Implementations

impl<const BASE: usize> Add for Tight<BASE>

type Output = Tight<BASE>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const BASE: usize> AddAssign for Tight<BASE>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const BASE: usize> BigInt<BASE> for Tight<BASE>

fn normalized(self) -> Self

Return a normalized version of the int. Remove trailing zeros, disable the parity flag if the resulting number is zero, and align the internal bits to the beginning of the data array.

type Builder = TightBuilder<BASE>

type Denormal = Denormal<BASE, Tight<BASE>>

fn len(&self) -> usize

The length of the big int in digits.

fn get_digit(&self, digit: usize) -> Option<Digit>

Get the digit of the big int at position digit, or None if the number does not have that many digits.

fn set_digit(&mut self, digit: usize, value: Digit)

Set the digit of the big int to value at position digit.

fn zero() -> Self

The value zero represented as a big int.

fn sign(&self) -> Sign

The sign of the big int.

fn with_sign(self, sign: Sign) -> Self

The big int with the given sign.

fn set_sign(&mut self, sign: Sign)

Set the sign of the big int to sign.

fn push_back(&mut self, digit: Digit)

Append a digit to the right side of the int. Equivalent to (int << 1) + digit

unsafe fn push_front(&mut self, digit: Digit)

Append a digit to the left side of the int.

unsafe fn shr_assign_inner(&mut self, amount: usize)

Divide the int by BASE^amount in place.

unsafe fn shl_assign_inner(&mut self, amount: usize)

Multiply the int by BASE^amount in place.

unsafe fn pop_front(&mut self) -> Option<Digit>

Pop the leftmost digit from the end of the int, and return it.

unsafe fn pop_back(&mut self) -> Option<Digit>

Pop the rightmost digit from the end of the int, and return it.

const BITS_PER_DIGIT: usize = _

fn get_back_inner(&self, index: usize) -> Option<Digit>

Default implementation of big_int::GetBack.

fn default_inner() -> Self

Default implementation of Default.

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

Default implementation of Display.

fn partial_cmp_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> Option<Ordering>

Default implementation of PartialOrd.

fn cmp_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> Ordering

Default implementation of Ord.

fn eq_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> bool

Default implementation of PartialEq.

fn neg_inner(self) -> Self::Denormal

Default implementation of Neg.

fn add_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

Default implementation of Add.

unsafe fn add_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

Default implementation of AddAssign.

fn sub_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

Default implementation of Sub.

unsafe fn sub_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

Default implementation of SubAssign.

fn mul_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

Default implementation of Mul.

unsafe fn mul_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

Default implementation of MulAssign.

fn div_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> OUT::Denormal

Default implementation of Div.

unsafe fn div_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS)

Default implementation of DivAssign.

fn from_str_inner(s: &str) -> Result<Self::Denormal, BigIntError>

Default implementation of FromStr.

fn from_iter_inner<T: IntoIterator<Item = Digit>>(iter: T) -> Self::Denormal

Default implementation of FromIterator.

fn from_u128_inner(value: u128) -> Self::Denormal

Default implementation of From<_> for all unsigned primitive int types.

fn from_i128_inner(value: i128) -> Self::Denormal

Default implementation of From<_> for all signed primitive int types.

fn into_u128_inner(self) -> u128

Default implementation of Into<_> for all unsigned primitive int types.

fn into_i128_inner(self) -> i128

Default implementation of Into<_> for all signed primitive int types.

fn is_zero(&self) -> bool

Check if the big int is zero.

fn shr_inner(self, amount: usize) -> Self::Denormal

Divide the int by BASE^amount.

fn shl_inner(self, amount: usize) -> Self::Denormal

Multiply the int by BASE^amount.

fn div_rem_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<(OUT::Denormal, OUT::Denormal), BigIntError>

Divide one int by another, returning the quotient & remainder as a pair. Returns the result as a denormalized pair.

fn div_rem<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<(OUT, OUT), BigIntError>

Divide one int by another, returning the quotient & remainder as a pair.

fn exp_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT::Denormal, BigIntError>

Exponentiate the big int by rhs. Returns the result as a denormalized number.

fn exp<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT, BigIntError>

Exponentiate the big int by rhs.

fn log_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT::Denormal, BigIntError>

Compute the logarithm of the big int with the base rhs. Returns the result as a denormalized number.

fn log<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT, BigIntError>

Compute the logarithm of the big int with the base rhs.

fn root_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT::Denormal, BigIntError>

Compute the nth root of the big int, with root rhs. Returns the result as a denormalized number.

fn root<RHS: BigInt<BASE>, OUT: BigInt<BASE>>( self, rhs: RHS, ) -> Result<OUT, BigIntError>

Compute the nth root of the big int, with root rhs.

fn is_even(&self) -> bool

Check if the number is even.

fn iter<'a>(&'a self) -> BigIntIter<'a, BASE, Self>

Iterate over the digits of the int.

fn normalize(&mut self)

Normalize a big int in place. A normalized int:

fn display(&self, alphabet: &str) -> Result<String, BigIntError>

Convert a big int to a printable string using the provided alphabet alphabet. Display uses this method with the default alphabet STANDARD_ALPHABET.

fn parse(value: &str, alphabet: &str) -> Result<Self::Denormal, ParseError>

Parse a big int from a value: &str, referencing the provided alphabet to determine what characters represent which digits. FromStr uses this method with the default alphabet STANDARD_ALPHABET.

fn convert_inner<const TO: usize, OUT: BigInt<TO>>(self) -> OUT::Denormal

Convert an int from its own base to another target base, to another BigInt type, or both at once. Returns the result as a denormalized number.

fn convert<const TO: usize, OUT: BigInt<TO>>(self) -> OUT

Convert an int from its own base to another target base, to another BigInt type, or both at once.

fn cmp_magnitude<RHS: BigInt<BASE>>(&self, rhs: &RHS) -> Ordering

Compare the absolute magnitude of two big ints, ignoring their sign.

fn abs(self) -> Self

Return the absolute value of the int.

impl<const BASE: usize> Clone for Tight<BASE>

fn clone(&self) -> Tight<BASE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const BASE: usize> Debug for Tight<BASE>

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

Formats the value using the given formatter.

impl<const BASE: usize> Default for Tight<BASE>

fn default() -> Self

Returns the “default value” for a type.

impl<const BASE: usize> Display for Tight<BASE>

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

Formats the value using the given formatter.

impl<const BASE: usize> Div for Tight<BASE>

type Output = Tight<BASE>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const BASE: usize> DivAssign for Tight<BASE>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const BASE: usize> From<Tight<BASE>> for i128

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for i16

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for i32

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for i64

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for i8

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for isize

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for u128

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for u16

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for u32

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for u64

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for u8

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Tight<BASE>> for usize

fn from(value: Tight<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<TightBuilder<BASE>> for Tight<BASE>

fn from(value: TightBuilder<BASE>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<Vec<u64>> for Tight<BASE>

fn from(value: Vec<Digit>) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<i128> for Tight<BASE>

fn from(value: i128) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<i16> for Tight<BASE>

fn from(value: i16) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<i32> for Tight<BASE>

fn from(value: i32) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<i64> for Tight<BASE>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<i8> for Tight<BASE>

fn from(value: i8) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<isize> for Tight<BASE>

fn from(value: isize) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<u128> for Tight<BASE>

fn from(value: u128) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<u16> for Tight<BASE>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<u32> for Tight<BASE>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<u64> for Tight<BASE>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<u8> for Tight<BASE>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<const BASE: usize> From<usize> for Tight<BASE>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<const BASE: usize> FromIterator<u64> for Tight<BASE>

fn from_iter<T: IntoIterator<Item = Digit>>(iter: T) -> Self

Creates a value from an iterator.

impl<const BASE: usize> FromStr for Tight<BASE>

type Err = BigIntError

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<const BASE: usize> GetBack for Tight<BASE>

type Item = u64

fn get_back(&self, index: usize) -> Option<Digit>

Safely retrieve items from a collection with negative indexing. Returns None if the index is larger than the length of the collection.

impl<const BASE: usize> IntoIterator for Tight<BASE>

type Item = u64

The type of the elements being iterated over.

type IntoIter = BigIntIntoIter<BASE, Tight<BASE>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const BASE: usize> Mul for Tight<BASE>

type Output = Tight<BASE>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const BASE: usize> MulAssign for Tight<BASE>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const BASE: usize> Neg for Tight<BASE>

type Output = Tight<BASE>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const BASE: usize> Ord for Tight<BASE>

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<const BASE: usize> PartialEq for Tight<BASE>

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

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

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

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

impl<const BASE: usize> PartialOrd for Tight<BASE>

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<const BASE: usize> Shl for Tight<BASE>

type Output = Tight<BASE>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<const BASE: usize> ShlAssign for Tight<BASE>

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

impl<const BASE: usize> Shr for Tight<BASE>

type Output = Tight<BASE>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<const BASE: usize> ShrAssign for Tight<BASE>

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

impl<const BASE: usize> Sub for Tight<BASE>

type Output = Tight<BASE>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const BASE: usize> SubAssign for Tight<BASE>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const BASE: usize> Eq for Tight<BASE>