## Expand description

A collection of numeric types and traits for Rust.

This includes new types for big integers, rationals, and complex numbers,
new traits for generic programming on numeric properties like `Integer`

,
and generic range iterators.

### Example

This example uses the BigRational type and Newton’s method to approximate a square root to arbitrary precision:

```
use num::FromPrimitive;
use num::bigint::BigInt;
use num::rational::{Ratio, BigRational};
fn approx_sqrt(number: u64, iterations: usize) -> BigRational {
let start: Ratio<BigInt> = Ratio::from_integer(FromPrimitive::from_u64(number).unwrap());
let mut approx = start.clone();
for _ in 0..iterations {
approx = (&approx + (&start / &approx)) /
Ratio::from_integer(FromPrimitive::from_u64(2).unwrap());
}
approx
}
fn main() {
println!("{}", approx_sqrt(10, 4)); // prints 4057691201/1283082416
}
```

### Compatibility

The `num`

crate is tested for rustc 1.31 and greater.

## Modules

## Structs

- A big signed integer type.
- A big unsigned integer type.
- A complex number in Cartesian form.

## Traits

- Numbers which have upper and lower bounds
- Performs addition that returns
`None`

instead of wrapping around on overflow. - Performs division that returns
`None`

instead of panicking on division by zero and instead of wrapping around on underflow and overflow. - Performs multiplication that returns
`None`

instead of wrapping around on underflow or overflow. - Performs subtraction that returns
`None`

instead of wrapping around on underflow. - Generic trait for floating point numbers
- A generic trait for converting a number to a value.
- The base trait for numeric types, covering
`0`

and`1`

values, comparisons, basic numeric operations, and string conversion. - An interface for casting between machine scalars.
- Defines a multiplicative identity element for
`Self`

. - Generic trait for primitive integers.
- Saturating math operations. Deprecated, use
`SaturatingAdd`

,`SaturatingSub`

and`SaturatingMul`

instead. - Useful functions for signed numbers (i.e. numbers that can be negative).
- A generic trait for converting a value to a number.
- A trait for values which cannot be negative
- Defines an additive identity element for
`Self`

.

## Functions

- Computes the absolute value.
- The positive difference of two numbers.
- Cast from one machine scalar to another.
- Raises a value to the power of exp, returning
`None`

if an overflow occurred. - A value bounded by a minimum and a maximum
- Returns the multiplicative identity,
`1`

. - Raises a value to the power of exp, using exponentiation by squaring.
- Returns an iterator over the given range [start, stop) (that is, starting at start (inclusive), and ending at stop (exclusive)).
- Return an iterator over the range [start, stop]
- Return an iterator over the range [start, stop) by
`step`

. It handles overflow by stopping. - Return an iterator over the range [start, stop] by
`step`

. It handles overflow by stopping. - Returns the sign of the number.
- Returns the additive identity,
`0`

.

## Type Aliases

- Alias for arbitrary precision rationals.
- RationalDeprecatedAlias for a
`Ratio`

of machine-sized integers. - Alias for a
`Ratio`

of 32-bit-sized integers. - Alias for a
`Ratio`

of 64-bit-sized integers.