Crate num_bigint
source ·Expand description
Big Integer Types for Rust
- A
BigUint
is unsigned and represented as a vector of digits. - A
BigInt
is signed and is a combination ofBigUint
andSign
.
Common numerical operations are overloaded, so we can treat them the same way we treat other numbers.
§Example
use num_bigint::BigUint;
use num_traits::One;
// Calculate large fibonacci numbers.
fn fib(n: usize) -> BigUint {
let mut f0 = BigUint::ZERO;
let mut f1 = BigUint::one();
for _ in 0..n {
let f2 = f0 + &f1;
f0 = f1;
f1 = f2;
}
f0
}
// This is a very large number.
println!("fib(1000) = {}", fib(1000));
It’s easy to generate large random numbers:
use num_bigint::{ToBigInt, RandBigInt};
let mut rng = rand::thread_rng();
let a = rng.gen_bigint(1000);
let low = -10000.to_bigint().unwrap();
let high = 10000.to_bigint().unwrap();
let b = rng.gen_bigint_range(&low, &high);
// Probably an even larger number.
println!("{}", a * b);
See the “Features” section for instructions for enabling random number generation.
§Features
The std
crate feature is enabled by default, which enables [std::error::Error
]
implementations and some internal use of floating point approximations. This can be disabled by
depending on num-bigint
with default-features = false
. Either way, the alloc
crate is
always required for heap allocation of the BigInt
/BigUint
digits.
§Random Generation
num-bigint
supports the generation of random big integers when the rand
feature is enabled. To enable it include rand as
rand = "0.8"
num-bigint = { version = "0.4", features = ["rand"] }
Note that you must use the version of rand
that num-bigint
is compatible
with: 0.8
.
§Arbitrary Big Integers
num-bigint
supports arbitrary
and quickcheck
features to implement
[arbitrary::Arbitrary
] and [quickcheck::Arbitrary
], respectively, for both BigInt
and
BigUint
. These are useful for fuzzing and other forms of randomized testing.
§Serialization
The serde
feature adds implementations of [Serialize
][serde::Serialize] and
[Deserialize
][serde::Deserialize] for both BigInt
and BigUint
. Their serialized data is
generated portably, regardless of platform differences like the internal digit size.
§Compatibility
The num-bigint
crate is tested for rustc 1.60 and greater.
Structs§
- A big signed integer type.
- A big unsigned integer type.
- The error type returned when a checked conversion regarding big integer fails.
- An iterator of
u32
digits representation of aBigUint
orBigInt
, ordered least significant digit first. - An iterator of
u64
digits representation of aBigUint
orBigInt
, ordered least significant digit first.
Enums§
- A
Sign
is aBigInt
’s composing element.
Traits§
- A generic trait for converting a value to a
BigUint
.