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.31 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.