[][src]Crate num_bigint

A Big integer (signed version: BigInt, unsigned version: BigUint).

A BigUint is represented as a vector of BigDigits. A BigInt 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::{Zero, One};
use std::mem::replace;

// Calculate large fibonacci numbers.
fn fib(n: usize) -> BigUint {
    let mut f0: BigUint = Zero::zero();
    let mut f1: BigUint = One::one();
    for _ in 0..n {
        let f2 = f0 + &f1;
        // This is a low cost way of swapping f0 with f1 and f1 with f2.
        f0 = replace(&mut f1, f2);

// This is a very large number.
println!("fib(1000) = {}", fib(1000));

It's easy to generate large random numbers:

This example is not tested
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.7"
num-bigint = { version = "0.3", features = ["rand"] }

Note that you must use the version of rand that num-bigint is compatible with: 0.7.


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



A big signed integer type.


A big unsigned integer type.


A random distribution for BigUint and BigInt values of a particular bit size.


The error type returned when a checked conversion regarding big integer fails.


The back-end implementing rand's UniformSampler for BigInt.


The back-end implementing rand's UniformSampler for BigUint.



A Sign is a BigInt's composing element.



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.