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 of BigUint and Sign.

Common numerical operations are overloaded, so we can treat them the same way we treat other numbers.


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;

// 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.


The std crate feature is enabled by default, and is mandatory before Rust 1.36 and the stabilized alloc crate. If you depend on num-bigint with default-features = false, you must manually enable the std feature yourself if your compiler is not new enough.

§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.


The num-bigint crate is tested for rustc 1.60 and greater.




  • A trait for sampling random big integers.
  • A generic trait for converting a value to a BigInt. This may return None when converting from f32 or f64, and will always succeed when converting from any integer or unsigned primitive, or BigUint.
  • A generic trait for converting a value to a BigUint.