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:

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.60 and greater.

Modules

bigint

cast

complex

integer

iter

pow

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

Generic trait for floating point numbers

FromPrimitive

A generic trait for converting a number to a value.

Integer

Num

The base trait for numeric types, covering 0 and 1 values, comparisons, basic numeric operations, and string conversion.

NumCast

An interface for casting between machine scalars.

One

Defines a multiplicative identity element for Self.

PrimInt

Generic trait for primitive integers.

Saturating

Saturating math operations. Deprecated, use SaturatingAdd, SaturatingSub and SaturatingMul instead.

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.

cast

Cast from one machine scalar to another.

checked_pow

Raises a value to the power of exp, returning None if an overflow occurred.

clamp

A value bounded by a minimum and a maximum

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 Aliases

BigRational

Alias for arbitrary precision rationals.

RationalDeprecated

Alias for a Ratio of machine-sized integers.

Rational32

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

Rational64

Alias for a Ratio of 64-bit-sized integers.