Struct big_int::BigInt

pub struct BigInt<const BASE: usize, B: BigIntImplementation<{ BASE }>>(/* private fields */);

A big int.

Must be constructed with a specific implementation

Implementations

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> BigInt<BASE, B>

pub fn zero() -> Self

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

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

pub fn shl_assign(&mut self, amount: usize)

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

pub fn shr_assign(&mut self, amount: usize)

pub fn normalized(self) -> Self

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

pub fn div_rem(self, other: Self) -> Result<(Self, Self), BigIntError>

Divide one int by another, returning the quotient & remainder as a pair, or an error if dividing by zero. This algorithm has a different time complexity than BigInt::div_rem_lowmem which makes it faster for most use cases, but also uses more memory.

b - base
d - number of digits in quotient
Time complexity: O(d * log(b))
Memory complexity: O(d * log(b))

use big_int::prelude::*;

let a: LooseInt<10> = 999_999_999.into();
let b = 56_789.into();
assert_eq!(a.div_rem(b), Ok((17_609.into(), 2_498.into())));

pub fn convert<const TO: usize, T: BigIntImplementation<{ TO }>>( self ) -> BigInt<TO, T>

Convert an int from its own base to another target base.

use big_int::prelude::*;

assert_eq!(
    LooseInt::<10>::from(99825).convert(),
    LooseInt::<16>::from(99825)
);

pub fn cmp_magnitude(&self, rhs: &Self) -> Ordering

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

use big_int::prelude::*;
 
let a: TightInt<10> = (-105).into();
let b = 15.into();
assert!(a.cmp_magnitude(&b).is_gt());

Trait Implementations

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Add for BigInt<BASE, B>

type Output = BigInt<BASE, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> AddAssign for BigInt<BASE, B>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const BASE: usize, B: Clone + BigIntImplementation<{ BASE }>> Clone for BigInt<BASE, B>

fn clone(&self) -> BigInt<BASE, B>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const BASE: usize, B: Debug + BigIntImplementation<{ BASE }>> Debug for BigInt<BASE, B>

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

Formats the value using the given formatter.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Default for BigInt<BASE, B>

fn default() -> Self

Returns the “default value” for a type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Deref for BigInt<BASE, B>

type Target = B

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> DerefMut for BigInt<BASE, B>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Display for BigInt<BASE, B>

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

Formats the value using the given formatter.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Div for BigInt<BASE, B>

type Output = BigInt<BASE, B>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> DivAssign for BigInt<BASE, B>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<&[u64]> for BigInt<BASE, B>

fn from(value: &[Digit]) -> Self

Converts to this type from the input type.

impl<B: BigIntImplementation<256>> From<&[u8]> for BigInt<256, B>

fn from(value: &[u8]) -> Self

Converts to this type from the input type.

impl<const N: usize, B: BigIntImplementation<256>> From<&[u8; N]> for BigInt<256, B>

fn from(value: &[u8; N]) -> Self

Converts to this type from the input type.

impl<const BASE: usize, const N: usize, B: BigIntImplementation<{ BASE }>> From<[u64; N]> for BigInt<BASE, B>

fn from(value: [Digit; N]) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<B> for BigInt<BASE, B>

fn from(value: B) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for i128

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for i16

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for i32

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for i64

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for i8

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for isize

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for u128

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for u16

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for u32

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for u64

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for u8

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<BigInt<BASE, B>> for usize

fn from(value: BigInt<BASE, B>) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<Vec<u64>> for BigInt<BASE, B>

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

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<i128> for BigInt<BASE, B>

fn from(value: i128) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<i16> for BigInt<BASE, B>

fn from(value: i16) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<i32> for BigInt<BASE, B>

fn from(value: i32) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<i64> for BigInt<BASE, B>

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<i8> for BigInt<BASE, B>

fn from(value: i8) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<isize> for BigInt<BASE, B>

fn from(value: isize) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<u128> for BigInt<BASE, B>

fn from(value: u128) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<u16> for BigInt<BASE, B>

fn from(value: u16) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<u32> for BigInt<BASE, B>

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<u64> for BigInt<BASE, B>

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<u8> for BigInt<BASE, B>

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> From<usize> for BigInt<BASE, B>

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> FromIterator<u64> for BigInt<BASE, B>

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

Creates a value from an iterator.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> FromStr for BigInt<BASE, B>

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, B: BigIntImplementation<{ BASE }>> Mul for BigInt<BASE, B>

type Output = BigInt<BASE, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> MulAssign for BigInt<BASE, B>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Neg for BigInt<BASE, B>

type Output = BigInt<BASE, B>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const BASE: usize, B> Ord for BigInt<BASE, B>

where B: BigIntImplementation<{ 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 + PartialOrd,

Restrict a value to a certain interval.

impl<const BASE: usize, B: PartialEq + BigIntImplementation<{ BASE }>> PartialEq for BigInt<BASE, B>

fn eq(&self, other: &BigInt<BASE, B>) -> 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, B> PartialOrd for BigInt<BASE, B>

where B: BigIntImplementation<{ 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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Shl for BigInt<BASE, B>

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

Shifts a Loose big int left by multiples of its BASE (not by 2).

type Output = BigInt<BASE, B>

The resulting type after applying the << operator.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> ShlAssign for BigInt<BASE, B>

fn shl_assign(&mut self, rhs: Self)

Shifts a big int left by multiples of its BASE (not by 2).

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Shr for BigInt<BASE, B>

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

Shifts a big int right by multiples of its BASE (not by 2).

type Output = BigInt<BASE, B>

The resulting type after applying the >> operator.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> ShrAssign for BigInt<BASE, B>

fn shr_assign(&mut self, rhs: Self)

Shifts a big int right by multiples of its BASE (not by 2).

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> Sub for BigInt<BASE, B>

type Output = BigInt<BASE, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> SubAssign for BigInt<BASE, B>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const BASE: usize, B: Eq + BigIntImplementation<{ BASE }>> Eq for BigInt<BASE, B>

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> StructuralEq for BigInt<BASE, B>

impl<const BASE: usize, B: BigIntImplementation<{ BASE }>> StructuralPartialEq for BigInt<BASE, B>