Struct big_int::tight::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: TightInt<10> = 593.into();
let b = a * 96.into();
assert_eq!(b, 56928.into());

Trait Implementations

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

type Builder = TightBuilder<BASE>

type DigitIterator<'a> = TightIter<'a, BASE>

fn len(&self) -> usize

The length of the big int.

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 / the digit is negative.

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

Set the digit of the big int to value at position digit. Return Some(Digit) of the digit’s existing value, or None if no digit was set.

fn zero() -> Self

The constant 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 desired parity of 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. Will denormalize if the appended digit is a zero; make sure to call .normalize() afterwards to prevent undefined functionality.

fn shr_assign(&mut self, amount: usize)

Divide the int by BASE^amount in place.

fn shl_assign(&mut self, amount: usize)

Multiply the int by BASE^amount in place.

fn iter<'a>(&'a self) -> Self::DigitIterator<'a>

fn normalized(self) -> Self

Return a normalized version of the int. Remove trailing zeros, and disable the parity flag if the resulting number is zero.

fn shr(self, amount: usize) -> Self

Divide the int by BASE^amount.

fn shl(self, amount: usize) -> Self

Multiply the int by BASE^amount.

fn normalize(&mut self)

Normalize a Loose big int in place. Remove trailing zeros, and disable the parity flag if the resulting number is zero.

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

Parse a Loose 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.

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

fn build(self) -> Tight<BASE>

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

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

Returns a copy 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> From<Tight<BASE>> for TightBuilder<BASE>

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(builder: TightBuilder<BASE>) -> Self

Converts to this type from the input type.

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

fn eq(&self, other: &Tight<BASE>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

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

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

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