Struct Loose 

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

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

Each digit requires 8 bytes of storage, making this a very space-inefficient implementation for smaller bases. However, the lack of additional complexity improves runtime efficiency over the tightly-packed implementation.

use big_int::prelude::*;

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

Implementations

impl<const BASE: usize> Loose<BASE>

pub unsafe fn from_raw_parts(digits: Vec<Digit>) -> Self

Create a new loose int directly from a Vec of individual digits.

Ensure the resulting int is properly normalized, and that no digits are greater than or equal to the base, to preserve soundness.

To construct a negative int from raw parts, simply apply the negation operator (-) afterwards.

use big_int::prelude::*;

assert_eq!(
    -unsafe { Loose::<10>::from_raw_parts(vec![1, 5]) },
    (-15).into()
);

Trait Implementations

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

type Output = Loose<BASE>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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.

use big_int::prelude::*;

let n = unsafe { Loose::<10>::from_raw_parts(vec![0, 0, 8, 3]) };
assert_eq!(n.normalized(), 83.into());

type Builder = LooseBuilder<BASE>

type Denormal = Denormal<BASE, Loose<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 with_sign(self, sign: Sign) -> Self

The big int with the given sign.

fn sign(&self) -> Sign

The sign of the big int.

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_back(&mut self) -> Option<Digit>

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

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

Pop the leftmost 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 Loose<BASE>

fn clone(&self) -> Loose<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 Loose<BASE>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

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

Formats the value using the given formatter.

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

type Output = Loose<BASE>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<const BASE: usize> From<LooseBuilder<BASE>> for Loose<BASE>

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(value: i128) -> Self

Converts to this type from the input type.

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

fn from(value: i16) -> Self

Converts to this type from the input type.

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

fn from(value: i32) -> Self

Converts to this type from the input type.

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

fn from(value: i64) -> Self

Converts to this type from the input type.

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

fn from(value: i8) -> Self

Converts to this type from the input type.

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

fn from(value: isize) -> Self

Converts to this type from the input type.

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

fn from(value: u128) -> Self

Converts to this type from the input type.

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

fn from(value: u16) -> Self

Converts to this type from the input type.

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

fn from(value: u32) -> Self

Converts to this type from the input type.

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

fn from(value: u64) -> Self

Converts to this type from the input type.

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

fn from(value: u8) -> Self

Converts to this type from the input type.

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

fn from(value: usize) -> Self

Converts to this type from the input type.

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

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

Creates a value from an iterator.

impl<const BASE: usize> FromStr for Loose<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 Loose<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 Loose<BASE>

type Item = u64

The type of the elements being iterated over.

type IntoIter = BigIntIntoIter<BASE, Loose<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 Loose<BASE>

type Output = Loose<BASE>

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

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

type Output = Loose<BASE>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const BASE: usize> Ord for Loose<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 Loose<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 Loose<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 Loose<BASE>

type Output = Loose<BASE>

The resulting type after applying the << operator.

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

Performs the << operation.

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

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

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

type Output = Loose<BASE>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

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

type Output = Loose<BASE>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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