Crate num

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:

extern crate num; #[cfg(all(feature = "bigint", feature="rational"))] mod test { use num::FromPrimitive; use num::bigint::BigInt; use num::rational::{Ratio, BigRational}; pub 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 } } #[cfg(not(all(feature = "bigint", feature="rational")))] mod test { pub fn approx_sqrt(n: u64, _: usize) -> u64 { n } } use test::approx_sqrt; fn main() { println!("{}", approx_sqrt(10, 4)); // prints 4057691201/1283082416 }

extern crate num;

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
}

Reexports

pub extern crate num_traits;

pub extern crate num_integer;

pub extern crate num_iter;

pub extern crate num_complex;

pub extern crate num_bigint;

pub extern crate num_rational;

Modules

bigint
cast
complex
integer
iter
rational
traits

Structs

BigInt	A big signed integer type.
BigUint	A big unsigned integer type.
Complex	A complex number in Cartesian form.

Traits

Bounded	Numbers which have upper and lower bounds
CheckedAdd	Performs addition that returns None instead of wrapping around on overflow.
CheckedDiv	Performs division that returns None instead of panicking on division by zero and instead of wrapping around on underflow and overflow.
CheckedMul	Performs multiplication that returns None instead of wrapping around on underflow or overflow.
CheckedSub	Performs subtraction that returns None instead of wrapping around on underflow.
Float
FromPrimitive	A generic trait for converting a number to a value.
Integer
Num	The base trait for numeric types
NumCast	An interface for casting between machine scalars.
One	Defines a multiplicative identity element for Self.
PrimInt
Saturating	Saturating math operations
Signed	Useful functions for signed numbers (i.e. numbers that can be negative).
ToPrimitive	A generic trait for converting a value to a number.
Unsigned	A trait for values which cannot be negative
Zero	Defines an additive identity element for Self.

Functions

abs	Computes the absolute value.
abs_sub	The positive difference of two numbers.
checked_pow	Raises a value to the power of exp, returning None if an overflow occurred.
one	Returns the multiplicative identity, 1.
pow	Raises a value to the power of exp, using exponentiation by squaring.
range	Returns an iterator over the given range [start, stop) (that is, starting at start (inclusive), and ending at stop (exclusive)).
range_inclusive	Return an iterator over the range [start, stop]
range_step	Return an iterator over the range [start, stop) by step. It handles overflow by stopping.
range_step_inclusive	Return an iterator over the range [start, stop] by step. It handles overflow by stopping.
signum	Returns the sign of the number.
zero	Returns the additive identity, 0.

Type Definitions

BigRational
Rational