# [−][src]Crate num_bigint

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

    extern crate num_bigint;
    extern crate num_traits;

    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:

    extern crate rand;
    extern crate num_bigint as bigint;

    use 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);

## Compatibility

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

## Modules

big_digit |

## Structs

BigInt | A big signed integer type.
BigUint | A big unsigned integer type.

## Enums

ParseBigIntError |
Sign | A Sign is a `BigInt`'s composing element.

## Constants

ZERO_BIG_DIGIT |

## Traits

RandBigInt |
ToBigInt | A generic trait for converting a value to a `BigInt`.
ToBigUint | A generic trait for converting a value to a `BigUint`.

## Type Definitions

BigDigit | A `BigDigit` is a `BigUint`'s composing element.
DoubleBigDigit | A `DoubleBigDigit` is the internal type used to do the computations. Its size is the double of the size of `BigDigit`.

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)