# Crate num

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.

## 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.
• RationalDeprecated
Alias 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.