# [−][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.

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

## Compatibility

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

## Structs

 BigInt A big signed integer type. BigUint A big unsigned integer type. ParseBigIntError RandomBits A random distribution for BigUint and BigInt values of a particular bit size. TryFromBigIntError The error type returned when a checked conversion regarding big integer fails. UniformBigInt The back-end implementing rand's UniformSampler for BigInt. UniformBigUint The back-end implementing rand's UniformSampler for BigUint.

## Enums

 Sign A Sign is a BigInt's composing element.

## Traits

 RandBigInt A trait for sampling random big integers. ToBigInt 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. ToBigUint A generic trait for converting a value to a BigUint.