Crate big_int

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

base64 encoding & decoding, baked into the library :)

denormal

Denormalized numbers.

error

big int errors.

get_back

Safely retrieve items from a collection with negative indexing.

loose

Loosely packed big int implementations.

prelude

Default exports: includes Loose, Tight, Sign, & Denormal

tight

tightly packed big int implementation, for better memory efficiency.

Macros

bytestr

Format out a vec of bytes as a list of binary numbers.

mask

Safely create a bitmask of n bits in size shifted to the right side of the number without overflowing.

sdbg

dbg! but don’t multiline-print

test_pairs

Create a list of pairs of randomly generated ints, constrained by the sizes of the associated int types passed.

test_values

Create a list of randomly generated ints, constrained by the sizes of the associated int types passed.

Structs

BigIntIntoIter

A consuming iterator over the digits of a big int.

BigIntIter

An iterator over the digits of a big int.

Enums

Sign

Represents the sign of a big int; either Positive or Negative.

Constants

STANDARD_ALPHABET

Standard alphabet used when translating between text and big ints.

Traits

BigInt

A big int.

BigIntBuilder

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.

UnsafeInto

A conversion that may only be performed unsafely.

Unwrap

A value that may be unwrapped.

Type Aliases

Digit

Size of an individual big int digit.

Derive Macros

BigIntTraits