Expand description
big_int
- Arbitrary precision, arbitrary base integer arithmetic library.
use big_int::prelude::*;
let mut a: Loose<10> = "9000000000000000000000000000000000000000".parse().unwrap();
a /= 13.into();
assert_eq!(a, "692307692307692307692307692307692307692".parse().unwrap());
let mut b: Loose<16> = a.convert();
assert_eq!(b, "208D59C8D8669EDC306F76344EC4EC4EC".parse().unwrap());
b >>= 16.into();
let c: Loose<2> = b.convert();
assert_eq!(c, "100000100011010101100111001000110110000110011010011110110111000011".parse().unwrap());
let mut d: Tight<256> = c.convert();
d += vec![15, 90, 0].into();
assert_eq!(d, vec![2, 8, 213, 156, 141, 134, 121, 71, 195].into());
let e: Tight<10> = d.convert();
assert_eq!(format!("{e}"), "37530075201422313411".to_string());
This crate contains five primary big int implementations:
LooseBytes<BASE>
- A collection of loosely packed 8-bit byte values representing each digit. Slightly memory inefficient, but with minimal performance overhead. Capable of representing any base from 2-256.LooseShorts<BASE>
- A collection of loosely packed 16-bit short values representing each digit. Somewhat memory inefficient, but with minimal performance overhead. Capable of representing any base from 2-65536.LooseWords<BASE>
- A collection of loosely packed 32-bit word values representing each digit. Fairly memory inefficient, but with minimal performance overhead. Capable of representing any base from 2-2^32.Loose<BASE>
- A collection of loosely packed 64-bit ints representing each digit. Very memory inefficient, but with minimal performance overhead. Capable of representing any base from 2-2^64.Tight<BASE>
- A collection of tightly packed bits representing each digit. Maximally memory efficient, and capable of representing any base from 2-2^64. However, the additional indirection adds some performance overhead.
Ints support most basic arithmetic operations, including addition, subtraction, multiplication,
division, exponentiation, logarithm, nth root, and left/right shifting. Notably, shifting acts
on the BASE
of the associated number, increasing or decreasing the magnitude by powers of BASE
as opposed to powers of 2.
Modules
- base64 encoding & decoding, baked into the library :)
- Denormalized numbers.
- big int errors.
- Safely retrieve items from a collection with negative indexing.
- Loosely packed big int implementations.
- Default exports: includes
Loose
,Tight
,Sign
, &Denormal
- tightly packed big int implementation, for better memory efficiency.
Macros
- Format out a vec of bytes as a list of binary numbers.
- Safely create a bitmask of
n
bits in size shifted to the right side of the number without overflowing. - dbg! but don’t multiline-print
- Create a list of pairs of randomly generated ints, constrained by the sizes of the associated int types passed.
- Create a list of randomly generated ints, constrained by the sizes of the associated int types passed.
Structs
- A consuming iterator over the digits of a big int.
- An iterator over the digits of a big int.
Enums
- Represents the sign of a big int; either Positive or Negative.
Constants
- Standard alphabet used when translating between text and big ints.
Traits
- A big int.
- A builder for a big int. Use this to construct a big int one digit at a time, then call .into() to construct the final int.
- A conversion that may only be performed unsafely.
- A value that may be unwrapped.
Type Aliases
- Size of an individual big int digit.