Trait BigInt

Source

pub trait BigInt<const BASE: usize>where
    Self: GetBack<Item = Digit> + Clone + Default + Debug + Display + PartialEq + Eq + PartialOrd + Ord + Neg<Output = Self> + Add<Output = Self> + AddAssign + Sub<Output = Self> + SubAssign + Div<Output = Self> + DivAssign + Mul<Output = Self> + MulAssign + Shl<Output = Self> + ShlAssign + Shr<Output = Self> + ShrAssign + FromStr<Err = BigIntError> + FromIterator<Digit> + IntoIterator<Item = Digit, IntoIter = BigIntIntoIter<BASE, Self>> + From<Vec<Digit>> + From<u8> + From<u16> + From<u32> + From<u64> + From<u128> + From<usize> + From<i8> + From<i16> + From<i32> + From<i64> + From<i128> + From<isize> + Into<u8> + Into<u16> + Into<u32> + Into<u64> + Into<u128> + Into<usize> + Into<i8> + Into<i16> + Into<i32> + Into<i64> + Into<i128> + Into<isize>,{
    type Builder: BigIntBuilder<BASE> + Into<Self::Denormal> + Into<Self>;
    type Denormal: BigInt<BASE> + From<Self> + UnsafeInto<Self> + Unwrap<Self>;

    const BITS_PER_DIGIT: usize = _;
Show 55 methods
    // Required methods
    fn len(&self) -> usize;
    fn get_digit(&self, digit: usize) -> Option<Digit>;
    fn set_digit(&mut self, digit: usize, value: Digit);
    fn zero() -> Self;
    fn sign(&self) -> Sign;
    fn with_sign(self, sign: Sign) -> Self;
    fn set_sign(&mut self, sign: Sign);
    fn push_back(&mut self, digit: Digit);
    unsafe fn push_front(&mut self, digit: Digit);
    unsafe fn pop_back(&mut self) -> Option<Digit>;
    unsafe fn pop_front(&mut self) -> Option<Digit>;

    // Provided methods
    fn get_back_inner(&self, index: usize) -> Option<Digit> { ... }
    fn default_inner() -> Self { ... }
    fn fmt_inner(&self, f: &mut Formatter<'_>) -> Result { ... }
    fn partial_cmp_inner<RHS: BigInt<BASE>>(
        &self,
        other: &RHS,
    ) -> Option<Ordering> { ... }
    fn cmp_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> Ordering { ... }
    fn eq_inner<RHS: BigInt<BASE>>(&self, other: &RHS) -> bool { ... }
    fn neg_inner(self) -> Self::Denormal { ... }
    fn add_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> OUT::Denormal { ... }
    unsafe fn add_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS) { ... }
    fn sub_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> OUT::Denormal { ... }
    unsafe fn sub_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS) { ... }
    fn mul_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> OUT::Denormal { ... }
    unsafe fn mul_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS) { ... }
    fn div_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> OUT::Denormal { ... }
    unsafe fn div_assign_inner<RHS: BigInt<BASE>>(&mut self, rhs: RHS) { ... }
    fn from_str_inner(s: &str) -> Result<Self::Denormal, BigIntError> { ... }
    fn from_iter_inner<T: IntoIterator<Item = Digit>>(iter: T) -> Self::Denormal { ... }
    fn from_u128_inner(value: u128) -> Self::Denormal { ... }
    fn from_i128_inner(value: i128) -> Self::Denormal { ... }
    fn into_u128_inner(self) -> u128 { ... }
    fn into_i128_inner(self) -> i128 { ... }
    fn is_zero(&self) -> bool { ... }
    fn shr_inner(self, amount: usize) -> Self::Denormal { ... }
    unsafe fn shr_assign_inner(&mut self, amount: usize) { ... }
    fn shl_inner(self, amount: usize) -> Self::Denormal { ... }
    unsafe fn shl_assign_inner(&mut self, amount: usize) { ... }
    fn div_rem_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<(OUT::Denormal, OUT::Denormal), BigIntError> { ... }
    fn div_rem<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<(OUT, OUT), BigIntError> { ... }
    fn exp_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<OUT::Denormal, BigIntError> { ... }
    fn exp<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<OUT, BigIntError> { ... }
    fn log_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<OUT::Denormal, BigIntError> { ... }
    fn log<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<OUT, BigIntError> { ... }
    fn root_inner<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<OUT::Denormal, BigIntError> { ... }
    fn root<RHS: BigInt<BASE>, OUT: BigInt<BASE>>(
        self,
        rhs: RHS,
    ) -> Result<OUT, BigIntError> { ... }
    fn is_even(&self) -> bool { ... }
    fn iter<'a>(&'a self) -> BigIntIter<'a, BASE, Self> ⓘ { ... }
    fn normalized(self) -> Self { ... }
    fn normalize(&mut self) { ... }
    fn display(&self, alphabet: &str) -> Result<String, BigIntError> { ... }
    fn parse(value: &str, alphabet: &str) -> Result<Self::Denormal, ParseError> { ... }
    fn convert_inner<const TO: usize, OUT: BigInt<TO>>(self) -> OUT::Denormal { ... }
    fn convert<const TO: usize, OUT: BigInt<TO>>(self) -> OUT { ... }
    fn cmp_magnitude<RHS: BigInt<BASE>>(&self, rhs: &RHS) -> Ordering { ... }
    fn abs(self) -> Self { ... }
}

Expand description

A big int.

Represents an arbitrary precision, arbitrary base natural number.

Supports basic arithmetic operations, as well as all utilities necessary for coercing to and from various builtin types, such as primitive int types, Vecs, and Strings.

§For implementors:

If implementing this trait for your own type, don’t be alarmed by the massive list of Self constraints. Use the included derive macro big_int::BigIntTraits to automatically derive all traits using default *_inner implementations pre-provided by BigInt.

At least one of normalize or normalized must be defined to prevent recursion.
At least one of shl_inner or shl_assign_inner must be defined to prevent recursion.
At least one of shr_inner or shr_assign_inner must be defined to prevent recursion.\

use big_int::prelude::*;

let mut a = TightBuilder::<10>::new();
a.push_back(1);
a.push_back(0);
a.push_back(4);
let a: DenormalTight<10> = a.into();
let a: Tight<10> = a.unwrap();
assert_eq!(a, 104.into());

Provided Associated Constants§

Source

const BITS_PER_DIGIT: usize = _

Required Associated Types§

Source

type Builder: BigIntBuilder<BASE> + Into<Self::Denormal> + Into<Self>

Source

type Denormal: BigInt<BASE> + From<Self> + UnsafeInto<Self> + Unwrap<Self>

Required Methods§

Source

fn len(&self) -> usize

The length of the big int in digits.

use big_int::prelude::*;

let a: Tight<10> = 211864.into();
assert_eq!(a.len(), 6);

Source

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.

use big_int::prelude::*;

let a: Tight<10> = 12345.into();
assert_eq!(a.get_digit(2), Some(3));
assert_eq!(a.get_digit(6), None);

Source

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

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

If the set digit causes the leftmost digit of the number to be zero, the number will become denormal, and should be normalized before being used.

use big_int::prelude::*;

let mut a: Tight<10> = 10000.into();
a.set_digit(1, 7);
a.set_digit(4, 9);
assert_eq!(a, 17009.into());

Source

fn zero() -> Self

The value zero represented as a big int.

use big_int::prelude::*;

let a: Tight<10> = 13.into();
let b = 13.into();
assert_eq!(a - b, BigInt::zero());

Source

fn sign(&self) -> Sign

The sign of the big int.

use big_int::prelude::*;

let mut a: Tight<10> = 5.into();
assert_eq!(a.sign(), Positive);
a -= 14.into();
assert_eq!(a.sign(), Negative);

Source

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

The big int with the given sign.

use big_int::prelude::*;

let a: Tight<10> = 95.into();
assert_eq!(a.with_sign(Negative), (-95).into());

Source

fn set_sign(&mut self, sign: Sign)

Set the sign of the big int to sign.

use big_int::prelude::*;

let mut a: Tight<10> = (-109).into();
a.set_sign(Positive);
assert_eq!(a, 109.into());

Source

fn push_back(&mut self, digit: Digit)

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

use big_int::prelude::*;

let mut a: Tight<10> = 6.into();
a.push_back(1);
assert_eq!(a, 61.into());

Source

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

Append a digit to the left side of the int.

If a zero is pushed onto the end of the int, it will become denormalized.

use big_int::prelude::*;

let mut a: Tight<10> = 6.into();
unsafe {
    a.push_front(1);
}
assert_eq!(a.normalized(), 16.into());

Source

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

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

If the last digit is popped, the number will become denormalized.

use big_int::prelude::*;

let mut a: Tight<10> = 651.into();
let digit = unsafe { a.pop_back() };
assert_eq!(a, 65.into());
assert_eq!(digit, Some(1));

Source

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

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

If the last digit is popped, the number will become denormalized.

use big_int::prelude::*;

let mut a: Tight<10> = 651.into();
let digit = unsafe { a.pop_front() };
assert_eq!(a, 51.into());
assert_eq!(digit, Some(6));