# Crate num_bigint[−][src]

Expand description

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

A `BigUint` is represented as a vector of `BigDigit`s. 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.

### Example

``````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);
}
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 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, 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`.

### Compatibility

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

## Structs

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.

An iterator of `u32` digits representation of a `BigUint` or `BigInt`, ordered least significant digit first.

An iterator of `u64` digits representation of a `BigUint` or `BigInt`, ordered least significant digit first.

The back-end implementing rand’s `UniformSampler` for `BigInt`.

The back-end implementing rand’s `UniformSampler` for `BigUint`.

## Enums

A Sign is a `BigInt`’s composing element.

## Traits

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