Merge #99

99: Revive Float+Real in no_std thanks to libm r=cuviper a=yoanlcq

Greetings,

This is a hopeful fix for #75.  
Basically: Add `libm` as an optional dependency, and handle three possible cases depending on which features are enabled:
- std and libm: std is used;
- std and not libm: std is used;
- libm and not std: libm and FloatCore are used.

It was briefly mentioned that `libm` wasn't ready yet, but this was months ago, and I believe it is better not to wait for too long.  
If anything, bugs in `libm` should be fixed in `libm`; `num-traits` is only delegating its implementations to it; not to mention that the more `libm` is used, the likelier issues are to be found and hopefully fixed.

Thanks in advance!

Co-authored-by: Yoan Lecoq <yoanlecoq.io@gmail.com>
Co-authored-by: Josh Stone <cuviper@gmail.com>

.rustup.sh

@@ -1,16 +0,0 @@
-#!/bin/sh
-# Use rustup to locally run the same suite of tests as .travis.yml.
-# (You should first install/update 1.0.0, beta, and nightly.)
-
-set -ex
-
-for toolchain in 1.0.0 beta nightly; do
-    run="rustup run $toolchain"
-    $run cargo build --verbose
-    $run /usr/bin/env make test
-    $run $PWD/.travis/test_features.sh
-    if [ $toolchain = nightly ]; then
-        $run $PWD/.travis/test_nightly.sh
-    fi
-    $run cargo doc
-done

.travis.yml

@@ -1,21 +1,52 @@
 language: rust
+sudo: false
 rust:
-  - 1.0.0
+  - 1.8.0
+  - 1.15.0
+  - 1.20.0
+  - 1.26.0 # has_i128
+  - 1.31.0 # 2018!
+  - stable
   - beta
   - nightly
-sudo: false
 script:
   - cargo build --verbose
-  - make test
-  - .travis/test_features.sh
-  - |
-    [ $TRAVIS_RUST_VERSION != nightly ] || .travis/test_nightly.sh
-  - cargo doc
-after_success: |
-  [ $TRAVIS_BRANCH = master ] &&
-  [ $TRAVIS_PULL_REQUEST = false ] &&
-  [ $TRAVIS_RUST_VERSION = nightly ] &&
-  ssh-agent .travis/deploy.sh
+  - ./ci/test_full.sh
+matrix:
+  include:
+    # i586 presents floating point challenges for lack of SSE/SSE2
+    - name: "i586"
+      rust: stable
+      env: TARGET=i586-unknown-linux-gnu
+      addons:
+        apt:
+          packages:
+            - gcc-multilib
+      before_script:
+        - rustup target add $TARGET
+      script:
+        - cargo test --verbose --target $TARGET --all-features
+    # try a target that doesn't have std at all
+    - name: "no_std"
+      rust: stable
+      env: TARGET=thumbv6m-none-eabi
+      before_script:
+        - rustup target add $TARGET
+      script:
+        - cargo build --verbose --target $TARGET --no-default-features --features i128
+        - cargo build --verbose --target $TARGET --no-default-features --features libm
+    - name: "rustfmt"
+      rust: 1.31.0
+      before_script:
+        - rustup component add rustfmt
+      script:
+        - cargo fmt --all -- --check
 notifications:
   email:
     on_success: never
+branches:
+  only:
+    - master
+    - next
+    - staging
+    - trying

.travis/.gitignore

@@ -1 +0,0 @@
-/deploy

.travis/deploy.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-
-set -ex
-
-cp doc/* target/doc/
-pip install ghp-import --user
-$HOME/.local/bin/ghp-import -n target/doc
-
-openssl aes-256-cbc -K $encrypted_9e86330b283d_key -iv $encrypted_9e86330b283d_iv -in .travis/deploy.enc -out .travis/deploy -d
-chmod 600 .travis/deploy
-ssh-add .travis/deploy
-git push -qf ssh://git@github.com/${TRAVIS_REPO_SLUG}.git gh-pages

.travis/test_features.sh

@@ -1,7 +0,0 @@
-#!/bin/sh
-
-set -ex
-
-for feature in '' bigint rational complex; do
-  cargo build --verbose --no-default-features --features="$feature"
-done

.travis/test_nightly.sh

@@ -1,14 +0,0 @@
-#!/bin/sh
-
-set -ex
-
-cargo bench --verbose
-
-cargo test --verbose --manifest-path=macros/Cargo.toml
-
-# Build test for the serde feature
-cargo build --verbose --features "serde"
-
-# Downgrade serde and build test the 0.7.0 channel as well
-cargo update -p serde --precise 0.7.0
-cargo build --verbose --features "serde"

Cargo.toml

@@ -1,69 +1,28 @@
 [package]
 authors = ["The Rust Project Developers"]
-description = "A collection of numeric types and traits for Rust, including bigint,\ncomplex, rational, range iterators, generic integers, and more!\n"
-documentation = "http://rust-num.github.io/num"
-homepage = "https://github.com/rust-num/num"
+description = "Numeric traits for generic mathematics"
+documentation = "https://docs.rs/num-traits"
+homepage = "https://github.com/rust-num/num-traits"
 keywords = ["mathematics", "numerics"]
+categories = ["algorithms", "science", "no-std"]
 license = "MIT/Apache-2.0"
-repository = "https://github.com/rust-num/num"
-name = "num"
-version = "0.1.35"
+repository = "https://github.com/rust-num/num-traits"
+name = "num-traits"
+version = "0.2.8"
+readme = "README.md"
+build = "build.rs"
+exclude = ["/ci/*", "/.travis.yml", "/bors.toml"]
 
-[[bench]]
-name = "bigint"
-
-[[bench]]
-harness = false
-name = "shootout-pidigits"
+[package.metadata.docs.rs]
+features = ["std"]
 
 [dependencies]
-
-[dependencies.num-bigint]
-optional = true
-path = "bigint"
-version = "0.1.35"
-
-[dependencies.num-complex]
-optional = true
-path = "complex"
-version = "0.1.35"
-
-[dependencies.num-integer]
-path = "./integer"
-version = "0.1.32"
-
-[dependencies.num-iter]
-optional = false
-path = "iter"
-version = "0.1.32"
-
-[dependencies.num-rational]
-optional = true
-path = "rational"
-version = "0.1.35"
-
-[dependencies.num-traits]
-path = "./traits"
-version = "0.1.35"
-
-[dev-dependencies]
-
-[dev-dependencies.rand]
-version = "0.3.8"
+libm = { version = "0.1.4", optional = true }
 
 [features]
-bigint = ["num-bigint"]
-complex = ["num-complex"]
-rational = ["num-rational"]
-default = ["bigint", "complex", "rational", "rustc-serialize"]
+default = ["std"]
+std = []
+i128 = []
 
-serde = [
-  "num-bigint/serde",
-  "num-complex/serde",
-  "num-rational/serde"
-]
-rustc-serialize = [
-  "num-bigint/rustc-serialize",
-  "num-complex/rustc-serialize",
-  "num-rational/rustc-serialize"
-]
+[build-dependencies]
+autocfg = "0.1.3"

Makefile

@@ -1,14 +0,0 @@
-CARGO_CMD ?= cargo
-
-packages = bigint complex integer iter rational traits
-
-test:
-	$(MAKE) run-all TASK="test"
-
-run-all: $(packages)
-	$(CARGO_CMD) $(TASK)
-
-$(packages):
-	$(CARGO_CMD) $(TASK) --manifest-path $@/Cargo.toml
-
-.PHONY: $(packages) test

README.md

@@ -1,12 +1,11 @@
-# num
+# num-traits
 
-A collection of numeric types and traits for Rust.
+[![crate](https://img.shields.io/crates/v/num-traits.svg)](https://crates.io/crates/num-traits)
+[![documentation](https://docs.rs/num-traits/badge.svg)](https://docs.rs/num-traits)
+![minimum rustc 1.8](https://img.shields.io/badge/rustc-1.8+-red.svg)
+[![Travis status](https://travis-ci.org/rust-num/num-traits.svg?branch=master)](https://travis-ci.org/rust-num/num-traits)
 
-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.
-
-[Documentation](http://rust-num.github.io/num)
+Numeric traits for generic mathematics in Rust.
 
 ## Usage
 
@@ -14,11 +13,42 @@ Add this to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-num = "0.1"
+num-traits = "0.2"
 ```
 
 and this to your crate root:
 
 ```rust
-extern crate num;
+extern crate num_traits;
 ```
+
+## Features
+
+This crate can be used without the standard library (`#![no_std]`) by disabling
+the default `std` feature. Use this in `Cargo.toml`:
+
+```toml
+[dependencies.num-traits]
+version = "0.2"
+default-features = false
+# features = ["libm"]    # <--- Uncomment if you wish to use `Float` and `Real` without `std`
+```
+
+The `Float` and `Real` traits are only available when either `std` or `libm` is enabled.  
+The `libm` feature is only available with Rust 1.31 and later ([see PR #99](https://github.com/rust-num/num-traits/pull/99)).
+
+The `FloatCore` trait is always available.  `MulAdd` and `MulAddAssign` for `f32`
+and `f64` also require `std` or `libm`, as do implementations of signed and floating-
+point exponents in `Pow`.
+
+Implementations for `i128` and `u128` are only available with Rust 1.26 and
+later.  The build script automatically detects this, but you can make it
+mandatory by enabling the `i128` crate feature.
+
+## Releases
+
+Release notes are available in [RELEASES.md](RELEASES.md).
+
+## Compatibility
+
+The `num-traits` crate is tested for rustc 1.8 and greater.

RELEASES.md

@@ -0,0 +1,154 @@
+# Release 0.2.8 (2019-05-21)
+
+- [Fixed feature detection on `no_std` targets][116].
+
+**Contributors**: @cuviper
+
+[116]: https://github.com/rust-num/num-traits/pull/116
+
+# Release 0.2.7 (2019-05-20)
+
+- [Documented when `CheckedShl` and `CheckedShr` return `None`][90].
+- [The new `Zero::set_zero` and `One::set_one`][104] will set values to their
+  identities in place, possibly optimized better than direct assignment.
+- [Documented general features and intentions of `PrimInt`][108].
+
+**Contributors**: @cuviper, @dvdhrm, @ignatenkobrain, @lcnr, @samueltardieu
+
+[90]: https://github.com/rust-num/num-traits/pull/90
+[104]: https://github.com/rust-num/num-traits/pull/104
+[108]: https://github.com/rust-num/num-traits/pull/108
+
+# Release 0.2.6 (2018-09-13)
+
+- [Documented that `pow(0, 0)` returns `1`][79].  Mathematically, this is not
+  strictly defined, but the current behavior is a pragmatic choice that has
+  precedent in Rust `core` for the primitives and in many other languages.
+- [The new `WrappingShl` and `WrappingShr` traits][81] will wrap the shift count
+  if it exceeds the bit size of the type.
+
+**Contributors**: @cuviper, @edmccard, @meltinglava
+
+[79]: https://github.com/rust-num/num-traits/pull/79
+[81]: https://github.com/rust-num/num-traits/pull/81
+
+# Release 0.2.5 (2018-06-20)
+
+- [Documentation for `mul_add` now clarifies that it's not always faster.][70]
+- [The default methods in `FromPrimitive` and `ToPrimitive` are more robust.][73]
+
+**Contributors**: @cuviper, @frewsxcv
+
+[70]: https://github.com/rust-num/num-traits/pull/70
+[73]: https://github.com/rust-num/num-traits/pull/73
+
+# Release 0.2.4 (2018-05-11)
+
+- [Support for 128-bit integers is now automatically detected and enabled.][69]
+  Setting the `i128` crate feature now causes the build script to panic if such
+  support is not detected.
+
+**Contributors**: @cuviper
+
+[69]: https://github.com/rust-num/num-traits/pull/69
+
+# Release 0.2.3 (2018-05-10)
+
+- [The new `CheckedNeg` and `CheckedRem` traits][63] perform checked `Neg` and
+  `Rem`, returning `Some(output)` or `None` on overflow.
+- [The `no_std` implementation of `FloatCore::to_degrees` for `f32`][61] now
+  uses a constant for greater accuracy, mirroring [rust#47919].  (With `std` it
+  just calls the inherent `f32::to_degrees` in the standard library.)
+- [The new `MulAdd` and `MulAddAssign` traits][59] perform a fused multiply-
+  add.  For integer types this is just a convenience, but for floating point
+  types this produces a more accurate result than the separate operations.
+- [All applicable traits are now implemented for 128-bit integers][60] starting
+  with Rust 1.26, enabled by the new `i128` crate feature.  The `FromPrimitive`
+  and `ToPrimitive` traits now also have corresponding 128-bit methods, which
+  default to converting via 64-bit integers for compatibility.
+
+**Contributors**: @cuviper, @LEXUGE, @regexident, @vks
+
+[59]: https://github.com/rust-num/num-traits/pull/59
+[60]: https://github.com/rust-num/num-traits/pull/60
+[61]: https://github.com/rust-num/num-traits/pull/61
+[63]: https://github.com/rust-num/num-traits/pull/63
+[rust#47919]: https://github.com/rust-lang/rust/pull/47919
+
+# Release 0.2.2 (2018-03-18)
+
+- [Casting from floating point to integers now returns `None` on overflow][52],
+  avoiding [rustc's undefined behavior][rust-10184]. This applies to the `cast`
+  function and the traits `NumCast`, `FromPrimitive`, and `ToPrimitive`.
+
+**Contributors**: @apopiak, @cuviper, @dbarella
+
+[52]: https://github.com/rust-num/num-traits/pull/52
+[rust-10184]: https://github.com/rust-lang/rust/issues/10184
+
+
+# Release 0.2.1 (2018-03-01)
+
+- [The new `FloatCore` trait][32] offers a subset of `Float` for `#![no_std]` use.
+  [This includes everything][41] except the transcendental functions and FMA.
+- [The new `Inv` trait][37] returns the multiplicative inverse, or reciprocal.
+- [The new `Pow` trait][37] performs exponentiation, much like the existing `pow`
+  function, but with generic exponent types.
+- [The new `One::is_one` method][39] tests if a value equals 1.  Implementers
+  should override this method if there's a more efficient way to check for 1,
+  rather than comparing with a temporary `one()`.
+
+**Contributors**: @clarcharr, @cuviper, @vks
+
+[32]: https://github.com/rust-num/num-traits/pull/32
+[37]: https://github.com/rust-num/num-traits/pull/37
+[39]: https://github.com/rust-num/num-traits/pull/39
+[41]: https://github.com/rust-num/num-traits/pull/41
+
+
+# Release 0.2.0 (2018-02-06)
+
+- **breaking change**: [There is now a `std` feature][30], enabled by default, along
+  with the implication that building *without* this feature makes this a
+  `#![no_std]` crate.
+  - The `Float` and `Real` traits are only available when `std` is enabled.
+  - Otherwise, the API is unchanged, and num-traits 0.1.43 now re-exports its
+    items from num-traits 0.2 for compatibility (the [semver-trick]).
+
+**Contributors**: @cuviper, @termoshtt, @vks
+
+[semver-trick]: https://github.com/dtolnay/semver-trick
+[30]: https://github.com/rust-num/num-traits/pull/30
+
+
+# Release 0.1.43 (2018-02-06)
+
+- All items are now [re-exported from num-traits 0.2][31] for compatibility.
+
+[31]: https://github.com/rust-num/num-traits/pull/31
+
+
+# Release 0.1.42 (2018-01-22)
+
+- [num-traits now has its own source repository][num-356] at [rust-num/num-traits][home].
+- [`ParseFloatError` now implements `Display`][22].
+- [The new `AsPrimitive` trait][17] implements generic casting with the `as` operator.
+- [The new `CheckedShl` and `CheckedShr` traits][21] implement generic
+  support for the `checked_shl` and `checked_shr` methods on primitive integers.
+- [The new `Real` trait][23] offers a subset of `Float` functionality that may be applicable to more
+  types, with a blanket implementation for all existing `T: Float` types.
+
+Thanks to @cuviper, @Enet4, @fabianschuiki, @svartalf, and @yoanlcq for their contributions!
+
+[home]: https://github.com/rust-num/num-traits
+[num-356]: https://github.com/rust-num/num/pull/356
+[17]: https://github.com/rust-num/num-traits/pull/17
+[21]: https://github.com/rust-num/num-traits/pull/21
+[22]: https://github.com/rust-num/num-traits/pull/22
+[23]: https://github.com/rust-num/num-traits/pull/23
+
+
+# Prior releases
+
+No prior release notes were kept.  Thanks all the same to the many
+contributors that have made this crate what it is!

benches/bigint.rs

@@ -1,252 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate num;
-extern crate rand;
-
-use std::mem::replace;
-use test::Bencher;
-use num::{BigInt, BigUint, Zero, One, FromPrimitive};
-use num::bigint::RandBigInt;
-use rand::{SeedableRng, StdRng};
-
-fn get_rng() -> StdRng {
-    let seed: &[_] = &[1, 2, 3, 4];
-    SeedableRng::from_seed(seed)
-}
-
-fn multiply_bench(b: &mut Bencher, xbits: usize, ybits: usize) {
-    let mut rng = get_rng();
-    let x = rng.gen_bigint(xbits);
-    let y = rng.gen_bigint(ybits);
-
-    b.iter(|| &x * &y);
-}
-
-fn divide_bench(b: &mut Bencher, xbits: usize, ybits: usize) {
-    let mut rng = get_rng();
-    let x = rng.gen_bigint(xbits);
-    let y = rng.gen_bigint(ybits);
-
-    b.iter(|| &x / &y);
-}
-
-fn factorial(n: usize) -> BigUint {
-    let mut f: BigUint = One::one();
-    for i in 1..(n+1) {
-        let bu: BigUint = FromPrimitive::from_usize(i).unwrap();
-        f = f * bu;
-    }
-    f
-}
-
-/// Compute Fibonacci numbers
-fn fib(n: usize) -> BigUint {
-    let mut f0: BigUint = Zero::zero();
-    let mut f1: BigUint = One::one();
-    for _ in 0..n {
-        let f2 = f0 + &f1;
-        f0 = replace(&mut f1, f2);
-    }
-    f0
-}
-
-/// Compute Fibonacci numbers with two ops per iteration
-/// (add and subtract, like issue #200)
-fn fib2(n: usize) -> BigUint {
-    let mut f0: BigUint = Zero::zero();
-    let mut f1: BigUint = One::one();
-    for _ in 0..n {
-        f1 = f1 + &f0;
-        f0 = &f1 - f0;
-    }
-    f0
-}
-
-#[bench]
-fn multiply_0(b: &mut Bencher) {
-    multiply_bench(b, 1 << 8, 1 << 8);
-}
-
-#[bench]
-fn multiply_1(b: &mut Bencher) {
-    multiply_bench(b, 1 << 8, 1 << 16);
-}
-
-#[bench]
-fn multiply_2(b: &mut Bencher) {
-    multiply_bench(b, 1 << 16, 1 << 16);
-}
-
-#[bench]
-fn divide_0(b: &mut Bencher) {
-    divide_bench(b, 1 << 8, 1 << 6);
-}
-
-#[bench]
-fn divide_1(b: &mut Bencher) {
-    divide_bench(b, 1 << 12, 1 << 8);
-}
-
-#[bench]
-fn divide_2(b: &mut Bencher) {
-    divide_bench(b, 1 << 16, 1 << 12);
-}
-
-#[bench]
-fn factorial_100(b: &mut Bencher) {
-    b.iter(|| factorial(100));
-}
-
-#[bench]
-fn fib_100(b: &mut Bencher) {
-    b.iter(|| fib(100));
-}
-
-#[bench]
-fn fib_1000(b: &mut Bencher) {
-    b.iter(|| fib(1000));
-}
-
-#[bench]
-fn fib_10000(b: &mut Bencher) {
-    b.iter(|| fib(10000));
-}
-
-#[bench]
-fn fib2_100(b: &mut Bencher) {
-    b.iter(|| fib2(100));
-}
-
-#[bench]
-fn fib2_1000(b: &mut Bencher) {
-    b.iter(|| fib2(1000));
-}
-
-#[bench]
-fn fib2_10000(b: &mut Bencher) {
-    b.iter(|| fib2(10000));
-}
-
-#[bench]
-fn fac_to_string(b: &mut Bencher) {
-    let fac = factorial(100);
-    b.iter(|| fac.to_string());
-}
-
-#[bench]
-fn fib_to_string(b: &mut Bencher) {
-    let fib = fib(100);
-    b.iter(|| fib.to_string());
-}
-
-fn to_str_radix_bench(b: &mut Bencher, radix: u32) {
-    let mut rng = get_rng();
-    let x = rng.gen_bigint(1009);
-    b.iter(|| x.to_str_radix(radix));
-}
-
-#[bench]
-fn to_str_radix_02(b: &mut Bencher) {
-    to_str_radix_bench(b, 2);
-}
-
-#[bench]
-fn to_str_radix_08(b: &mut Bencher) {
-    to_str_radix_bench(b, 8);
-}
-
-#[bench]
-fn to_str_radix_10(b: &mut Bencher) {
-    to_str_radix_bench(b, 10);
-}
-
-#[bench]
-fn to_str_radix_16(b: &mut Bencher) {
-    to_str_radix_bench(b, 16);
-}
-
-#[bench]
-fn to_str_radix_36(b: &mut Bencher) {
-    to_str_radix_bench(b, 36);
-}
-
-fn from_str_radix_bench(b: &mut Bencher, radix: u32) {
-    use num::Num;
-    let mut rng = get_rng();
-    let x = rng.gen_bigint(1009);
-    let s = x.to_str_radix(radix);
-    assert_eq!(x, BigInt::from_str_radix(&s, radix).unwrap());
-    b.iter(|| BigInt::from_str_radix(&s, radix));
-}
-
-#[bench]
-fn from_str_radix_02(b: &mut Bencher) {
-    from_str_radix_bench(b, 2);
-}
-
-#[bench]
-fn from_str_radix_08(b: &mut Bencher) {
-    from_str_radix_bench(b, 8);
-}
-
-#[bench]
-fn from_str_radix_10(b: &mut Bencher) {
-    from_str_radix_bench(b, 10);
-}
-
-#[bench]
-fn from_str_radix_16(b: &mut Bencher) {
-    from_str_radix_bench(b, 16);
-}
-
-#[bench]
-fn from_str_radix_36(b: &mut Bencher) {
-    from_str_radix_bench(b, 36);
-}
-
-#[bench]
-fn shl(b: &mut Bencher) {
-    let n = BigUint::one() << 1000;
-    b.iter(|| {
-        let mut m = n.clone();
-        for i in 0..50 {
-            m = m << i;
-        }
-    })
-}
-
-#[bench]
-fn shr(b: &mut Bencher) {
-    let n = BigUint::one() << 2000;
-    b.iter(|| {
-        let mut m = n.clone();
-        for i in 0..50 {
-            m = m >> i;
-        }
-    })
-}
-
-#[bench]
-fn hash(b: &mut Bencher) {
-    use std::collections::HashSet;
-    let mut rng = get_rng();
-    let v: Vec<BigInt> = (1000..2000).map(|bits| rng.gen_bigint(bits)).collect();
-    b.iter(|| {
-        let h: HashSet<&BigInt> = v.iter().collect();
-        assert_eq!(h.len(), v.len());
-    });
-}
-
-#[bench]
-fn pow_bench(b: &mut Bencher) {
-    b.iter(|| {
-        let upper = 100_usize;
-        for i in 2..upper + 1 {
-            for j in 2..upper + 1 {
-                let i_big = BigUint::from_usize(i).unwrap();
-                num::pow(i_big, j);
-            }
-        }
-    });
-}

benches/shootout-pidigits.rs

@@ -1,131 +0,0 @@
-// The Computer Language Benchmarks Game
-// http://benchmarksgame.alioth.debian.org/
-//
-// contributed by the Rust Project Developers
-
-// Copyright (c) 2013-2014 The Rust Project Developers
-//
-// All rights reserved.
-//
-// Redistribution and use in source and binary forms, with or without
-// modification, are permitted provided that the following conditions
-// are met:
-//
-// - Redistributions of source code must retain the above copyright
-//   notice, this list of conditions and the following disclaimer.
-//
-// - Redistributions in binary form must reproduce the above copyright
-//   notice, this list of conditions and the following disclaimer in
-//   the documentation and/or other materials provided with the
-//   distribution.
-//
-// - Neither the name of "The Computer Language Benchmarks Game" nor
-//   the name of "The Computer Language Shootout Benchmarks" nor the
-//   names of its contributors may be used to endorse or promote
-//   products derived from this software without specific prior
-//   written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-// COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-// OF THE POSSIBILITY OF SUCH DAMAGE.
-
-extern crate num;
-
-use std::str::FromStr;
-use std::io;
-
-use num::traits::{FromPrimitive, ToPrimitive};
-use num::{BigInt, Integer, One, Zero};
-
-struct Context {
-    numer: BigInt,
-    accum: BigInt,
-    denom: BigInt,
-}
-
-impl Context {
-    fn new() -> Context {
-        Context {
-            numer: One::one(),
-            accum: Zero::zero(),
-            denom: One::one(),
-        }
-    }
-
-    fn from_i32(i: i32) -> BigInt {
-        FromPrimitive::from_i32(i).unwrap()
-    }
-
-    fn extract_digit(&self) -> i32 {
-        if self.numer > self.accum {return -1;}
-        let (q, r) =
-            (&self.numer * Context::from_i32(3) + &self.accum)
-            .div_rem(&self.denom);
-        if r + &self.numer >= self.denom {return -1;}
-        q.to_i32().unwrap()
-    }
-
-    fn next_term(&mut self, k: i32) {
-        let y2 = Context::from_i32(k * 2 + 1);
-        self.accum = (&self.accum + (&self.numer << 1)) * &y2;
-        self.numer = &self.numer * Context::from_i32(k);
-        self.denom = &self.denom * y2;
-    }
-
-    fn eliminate_digit(&mut self, d: i32) {
-        let d = Context::from_i32(d);
-        let ten = Context::from_i32(10);
-        self.accum = (&self.accum - &self.denom * d) * &ten;
-        self.numer = &self.numer * ten;
-    }
-}
-
-fn pidigits(n: isize, out: &mut io::Write) -> io::Result<()> {
-    let mut k = 0;
-    let mut context = Context::new();
-
-    for i in 1..(n+1) {
-        let mut d;
-        loop {
-            k += 1;
-            context.next_term(k);
-            d = context.extract_digit();
-            if d != -1 {break;}
-        }
-
-        try!(write!(out, "{}", d));
-        if i % 10 == 0 { try!(write!(out, "\t:{}\n", i)); }
-
-        context.eliminate_digit(d);
-    }
-
-    let m = n % 10;
-    if m != 0 {
-        for _ in m..10 { try!(write!(out, " ")); }
-        try!(write!(out, "\t:{}\n", n));
-    }
-    Ok(())
-}
-
-const DEFAULT_DIGITS: isize = 512;
-
-fn main() {
-    let args = std::env::args().collect::<Vec<_>>();
-    let n = if args.len() < 2 {
-        DEFAULT_DIGITS
-    } else if args[1] == "--bench" {
-        return pidigits(DEFAULT_DIGITS, &mut std::io::sink()).unwrap()
-    } else {
-        FromStr::from_str(&args[1]).unwrap()
-    };
-    pidigits(n, &mut std::io::stdout()).unwrap();
-}

bigint/Cargo.toml

@@ -1,35 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-description = "Big integer implementation for Rust"
-documentation = "http://rust-num.github.io/num"
-homepage = "https://github.com/rust-num/num"
-keywords = ["mathematics", "numerics"]
-license = "MIT/Apache-2.0"
-name = "num-bigint"
-repository = "https://github.com/rust-num/num"
-version = "0.1.35"
-
-[dependencies]
-
-[dependencies.num-integer]
-path = "../integer"
-version = "0.1.32"
-
-[dependencies.num-traits]
-path = "../traits"
-version = "0.1.32"
-
-[dependencies.rand]
-optional = true
-version = "0.3.14"
-
-[dependencies.rustc-serialize]
-optional = true
-version = "0.3.19"
-
-[dependencies.serde]
-optional = true
-version = ">= 0.7.0, < 0.9.0"
-
-[features]
-default = ["rand", "rustc-serialize"]

bigint/src/algorithms.rs

@@ -1,586 +0,0 @@
-use std::borrow::Cow;
-use std::cmp;
-use std::cmp::Ordering::{self, Less, Greater, Equal};
-use std::iter::repeat;
-use std::mem;
-use traits;
-use traits::{Zero, One};
-
-use biguint::BigUint;
-
-use bigint::Sign;
-use bigint::Sign::{Minus, NoSign, Plus};
-
-#[allow(non_snake_case)]
-pub mod big_digit {
-    /// A `BigDigit` is a `BigUint`'s composing element.
-    pub type BigDigit = u32;
-
-    /// A `DoubleBigDigit` is the internal type used to do the computations.  Its
-    /// size is the double of the size of `BigDigit`.
-    pub type DoubleBigDigit = u64;
-
-    pub const ZERO_BIG_DIGIT: BigDigit = 0;
-
-    // `DoubleBigDigit` size dependent
-    pub const BITS: usize = 32;
-
-    pub const BASE: DoubleBigDigit = 1 << BITS;
-    const LO_MASK: DoubleBigDigit = (-1i32 as DoubleBigDigit) >> BITS;
-
-    #[inline]
-    fn get_hi(n: DoubleBigDigit) -> BigDigit {
-        (n >> BITS) as BigDigit
-    }
-    #[inline]
-    fn get_lo(n: DoubleBigDigit) -> BigDigit {
-        (n & LO_MASK) as BigDigit
-    }
-
-    /// Split one `DoubleBigDigit` into two `BigDigit`s.
-    #[inline]
-    pub fn from_doublebigdigit(n: DoubleBigDigit) -> (BigDigit, BigDigit) {
-        (get_hi(n), get_lo(n))
-    }
-
-    /// Join two `BigDigit`s into one `DoubleBigDigit`
-    #[inline]
-    pub fn to_doublebigdigit(hi: BigDigit, lo: BigDigit) -> DoubleBigDigit {
-        (lo as DoubleBigDigit) | ((hi as DoubleBigDigit) << BITS)
-    }
-}
-
-use big_digit::{BigDigit, DoubleBigDigit};
-
-// Generic functions for add/subtract/multiply with carry/borrow:
-
-// Add with carry:
-#[inline]
-fn adc(a: BigDigit, b: BigDigit, carry: &mut BigDigit) -> BigDigit {
-    let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) + (b as DoubleBigDigit) +
-                                                  (*carry as DoubleBigDigit));
-
-    *carry = hi;
-    lo
-}
-
-// Subtract with borrow:
-#[inline]
-fn sbb(a: BigDigit, b: BigDigit, borrow: &mut BigDigit) -> BigDigit {
-    let (hi, lo) = big_digit::from_doublebigdigit(big_digit::BASE + (a as DoubleBigDigit) -
-                                                  (b as DoubleBigDigit) -
-                                                  (*borrow as DoubleBigDigit));
-    // hi * (base) + lo == 1*(base) + ai - bi - borrow
-    // => ai - bi - borrow < 0 <=> hi == 0
-    *borrow = (hi == 0) as BigDigit;
-    lo
-}
-
-#[inline]
-pub fn mac_with_carry(a: BigDigit, b: BigDigit, c: BigDigit, carry: &mut BigDigit) -> BigDigit {
-    let (hi, lo) = big_digit::from_doublebigdigit((a as DoubleBigDigit) +
-                                                  (b as DoubleBigDigit) * (c as DoubleBigDigit) +
-                                                  (*carry as DoubleBigDigit));
-    *carry = hi;
-    lo
-}
-
-/// Divide a two digit numerator by a one digit divisor, returns quotient and remainder:
-///
-/// Note: the caller must ensure that both the quotient and remainder will fit into a single digit.
-/// This is _not_ true for an arbitrary numerator/denominator.
-///
-/// (This function also matches what the x86 divide instruction does).
-#[inline]
-fn div_wide(hi: BigDigit, lo: BigDigit, divisor: BigDigit) -> (BigDigit, BigDigit) {
-    debug_assert!(hi < divisor);
-
-    let lhs = big_digit::to_doublebigdigit(hi, lo);
-    let rhs = divisor as DoubleBigDigit;
-    ((lhs / rhs) as BigDigit, (lhs % rhs) as BigDigit)
-}
-
-pub fn div_rem_digit(mut a: BigUint, b: BigDigit) -> (BigUint, BigDigit) {
-    let mut rem = 0;
-
-    for d in a.data.iter_mut().rev() {
-        let (q, r) = div_wide(rem, *d, b);
-        *d = q;
-        rem = r;
-    }
-
-    (a.normalize(), rem)
-}
-
-// Only for the Add impl:
-#[must_use]
-#[inline]
-pub fn __add2(a: &mut [BigDigit], b: &[BigDigit]) -> BigDigit {
-    debug_assert!(a.len() >= b.len());
-
-    let mut carry = 0;
-    let (a_lo, a_hi) = a.split_at_mut(b.len());
-
-    for (a, b) in a_lo.iter_mut().zip(b) {
-        *a = adc(*a, *b, &mut carry);
-    }
-
-    if carry != 0 {
-        for a in a_hi {
-            *a = adc(*a, 0, &mut carry);
-            if carry == 0 { break }
-        }
-    }
-
-    carry
-}
-
-/// /Two argument addition of raw slices:
-/// a += b
-///
-/// The caller _must_ ensure that a is big enough to store the result - typically this means
-/// resizing a to max(a.len(), b.len()) + 1, to fit a possible carry.
-pub fn add2(a: &mut [BigDigit], b: &[BigDigit]) {
-    let carry = __add2(a, b);
-
-    debug_assert!(carry == 0);
-}
-
-pub fn sub2(a: &mut [BigDigit], b: &[BigDigit]) {
-    let mut borrow = 0;
-
-    let len = cmp::min(a.len(), b.len());
-    let (a_lo, a_hi) = a.split_at_mut(len);
-    let (b_lo, b_hi) = b.split_at(len);
-
-    for (a, b) in a_lo.iter_mut().zip(b_lo) {
-        *a = sbb(*a, *b, &mut borrow);
-    }
-
-    if borrow != 0 {
-        for a in a_hi {
-            *a = sbb(*a, 0, &mut borrow);
-            if borrow == 0 { break }
-        }
-    }
-
-    // note: we're _required_ to fail on underflow
-    assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0),
-            "Cannot subtract b from a because b is larger than a.");
-}
-
-pub fn sub2rev(a: &[BigDigit], b: &mut [BigDigit]) {
-    debug_assert!(b.len() >= a.len());
-
-    let mut borrow = 0;
-
-    let len = cmp::min(a.len(), b.len());
-    let (a_lo, a_hi) = a.split_at(len);
-    let (b_lo, b_hi) = b.split_at_mut(len);
-
-    for (a, b) in a_lo.iter().zip(b_lo) {
-        *b = sbb(*a, *b, &mut borrow);
-    }
-
-    assert!(a_hi.is_empty());
-
-    // note: we're _required_ to fail on underflow
-    assert!(borrow == 0 && b_hi.iter().all(|x| *x == 0),
-            "Cannot subtract b from a because b is larger than a.");
-}
-
-pub fn sub_sign(a: &[BigDigit], b: &[BigDigit]) -> (Sign, BigUint) {
-    // Normalize:
-    let a = &a[..a.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)];
-    let b = &b[..b.iter().rposition(|&x| x != 0).map_or(0, |i| i + 1)];
-
-    match cmp_slice(a, b) {
-        Greater => {
-            let mut a = a.to_vec();
-            sub2(&mut a, b);
-            (Plus, BigUint::new(a))
-        }
-        Less => {
-            let mut b = b.to_vec();
-            sub2(&mut b, a);
-            (Minus, BigUint::new(b))
-        }
-        _ => (NoSign, Zero::zero()),
-    }
-}
-
-/// Three argument multiply accumulate:
-/// acc += b * c
-fn mac_digit(acc: &mut [BigDigit], b: &[BigDigit], c: BigDigit) {
-    if c == 0 {
-        return;
-    }
-
-    let mut b_iter = b.iter();
-    let mut carry = 0;
-
-    for ai in acc.iter_mut() {
-        if let Some(bi) = b_iter.next() {
-            *ai = mac_with_carry(*ai, *bi, c, &mut carry);
-        } else if carry != 0 {
-            *ai = mac_with_carry(*ai, 0, c, &mut carry);
-        } else {
-            break;
-        }
-    }
-
-    assert!(carry == 0);
-}
-
-/// Three argument multiply accumulate:
-/// acc += b * c
-fn mac3(acc: &mut [BigDigit], b: &[BigDigit], c: &[BigDigit]) {
-    let (x, y) = if b.len() < c.len() {
-        (b, c)
-    } else {
-        (c, b)
-    };
-
-    // Karatsuba multiplication is slower than long multiplication for small x and y:
-    //
-    if x.len() <= 4 {
-        for (i, xi) in x.iter().enumerate() {
-            mac_digit(&mut acc[i..], y, *xi);
-        }
-    } else {
-        /*
-         * Karatsuba multiplication:
-         *
-         * The idea is that we break x and y up into two smaller numbers that each have about half
-         * as many digits, like so (note that multiplying by b is just a shift):
-         *
-         * x = x0 + x1 * b
-         * y = y0 + y1 * b
-         *
-         * With some algebra, we can compute x * y with three smaller products, where the inputs to
-         * each of the smaller products have only about half as many digits as x and y:
-         *
-         * x * y = (x0 + x1 * b) * (y0 + y1 * b)
-         *
-         * x * y = x0 * y0
-         *       + x0 * y1 * b
-         *       + x1 * y0 * b
-         *       + x1 * y1 * b^2
-         *
-         * Let p0 = x0 * y0 and p2 = x1 * y1:
-         *
-         * x * y = p0
-         *       + (x0 * y1 + x1 * p0) * b
-         *       + p2 * b^2
-         *
-         * The real trick is that middle term:
-         *
-         *         x0 * y1 + x1 * y0
-         *
-         *       = x0 * y1 + x1 * y0 - p0 + p0 - p2 + p2
-         *
-         *       = x0 * y1 + x1 * y0 - x0 * y0 - x1 * y1 + p0 + p2
-         *
-         * Now we complete the square:
-         *
-         *       = -(x0 * y0 - x0 * y1 - x1 * y0 + x1 * y1) + p0 + p2
-         *
-         *       = -((x1 - x0) * (y1 - y0)) + p0 + p2
-         *
-         * Let p1 = (x1 - x0) * (y1 - y0), and substitute back into our original formula:
-         *
-         * x * y = p0
-         *       + (p0 + p2 - p1) * b
-         *       + p2 * b^2
-         *
-         * Where the three intermediate products are:
-         *
-         * p0 = x0 * y0
-         * p1 = (x1 - x0) * (y1 - y0)
-         * p2 = x1 * y1
-         *
-         * In doing the computation, we take great care to avoid unnecessary temporary variables
-         * (since creating a BigUint requires a heap allocation): thus, we rearrange the formula a
-         * bit so we can use the same temporary variable for all the intermediate products:
-         *
-         * x * y = p2 * b^2 + p2 * b
-         *       + p0 * b + p0
-         *       - p1 * b
-         *
-         * The other trick we use is instead of doing explicit shifts, we slice acc at the
-         * appropriate offset when doing the add.
-         */
-
-        /*
-         * When x is smaller than y, it's significantly faster to pick b such that x is split in
-         * half, not y:
-         */
-        let b = x.len() / 2;
-        let (x0, x1) = x.split_at(b);
-        let (y0, y1) = y.split_at(b);
-
-        /*
-         * We reuse the same BigUint for all the intermediate multiplies and have to size p
-         * appropriately here: x1.len() >= x0.len and y1.len() >= y0.len():
-         */
-        let len = x1.len() + y1.len() + 1;
-        let mut p = BigUint { data: vec![0; len] };
-
-        // p2 = x1 * y1
-        mac3(&mut p.data[..], x1, y1);
-
-        // Not required, but the adds go faster if we drop any unneeded 0s from the end:
-        p = p.normalize();
-
-        add2(&mut acc[b..],        &p.data[..]);
-        add2(&mut acc[b * 2..],    &p.data[..]);
-
-        // Zero out p before the next multiply:
-        p.data.truncate(0);
-        p.data.extend(repeat(0).take(len));
-
-        // p0 = x0 * y0
-        mac3(&mut p.data[..], x0, y0);
-        p = p.normalize();
-
-        add2(&mut acc[..],                &p.data[..]);
-        add2(&mut acc[b..],        &p.data[..]);
-
-        // p1 = (x1 - x0) * (y1 - y0)
-        // We do this one last, since it may be negative and acc can't ever be negative:
-        let (j0_sign, j0) = sub_sign(x1, x0);
-        let (j1_sign, j1) = sub_sign(y1, y0);
-
-        match j0_sign * j1_sign {
-            Plus    => {
-                p.data.truncate(0);
-                p.data.extend(repeat(0).take(len));
-
-                mac3(&mut p.data[..], &j0.data[..], &j1.data[..]);
-                p = p.normalize();
-
-                sub2(&mut acc[b..], &p.data[..]);
-            },
-            Minus   => {
-                mac3(&mut acc[b..], &j0.data[..], &j1.data[..]);
-            },
-            NoSign  => (),
-        }
-    }
-}
-
-pub fn mul3(x: &[BigDigit], y: &[BigDigit]) -> BigUint {
-    let len = x.len() + y.len() + 1;
-    let mut prod = BigUint { data: vec![0; len] };
-
-    mac3(&mut prod.data[..], x, y);
-    prod.normalize()
-}
-
-pub fn div_rem(u: &BigUint, d: &BigUint) -> (BigUint, BigUint) {
-    if d.is_zero() {
-        panic!()
-    }
-    if u.is_zero() {
-        return (Zero::zero(), Zero::zero());
-    }
-    if *d == One::one() {
-        return (u.clone(), Zero::zero());
-    }
-
-    // Required or the q_len calculation below can underflow:
-    match u.cmp(d) {
-        Less => return (Zero::zero(), u.clone()),
-        Equal => return (One::one(), Zero::zero()),
-        Greater => {} // Do nothing
-    }
-
-    // This algorithm is from Knuth, TAOCP vol 2 section 4.3, algorithm D:
-    //
-    // First, normalize the arguments so the highest bit in the highest digit of the divisor is
-    // set: the main loop uses the highest digit of the divisor for generating guesses, so we
-    // want it to be the largest number we can efficiently divide by.
-    //
-    let shift = d.data.last().unwrap().leading_zeros() as usize;
-    let mut a = u << shift;
-    let b = d << shift;
-
-    // The algorithm works by incrementally calculating "guesses", q0, for part of the
-    // remainder. Once we have any number q0 such that q0 * b <= a, we can set
-    //
-    //     q += q0
-    //     a -= q0 * b
-    //
-    // and then iterate until a < b. Then, (q, a) will be our desired quotient and remainder.
-    //
-    // q0, our guess, is calculated by dividing the last few digits of a by the last digit of b
-    // - this should give us a guess that is "close" to the actual quotient, but is possibly
-    // greater than the actual quotient. If q0 * b > a, we simply use iterated subtraction
-    // until we have a guess such that q0 & b <= a.
-    //
-
-    let bn = *b.data.last().unwrap();
-    let q_len = a.data.len() - b.data.len() + 1;
-    let mut q = BigUint { data: vec![0; q_len] };
-
-    // We reuse the same temporary to avoid hitting the allocator in our inner loop - this is
-    // sized to hold a0 (in the common case; if a particular digit of the quotient is zero a0
-    // can be bigger).
-    //
-    let mut tmp = BigUint { data: Vec::with_capacity(2) };
-
-    for j in (0..q_len).rev() {
-        /*
-         * When calculating our next guess q0, we don't need to consider the digits below j
-         * + b.data.len() - 1: we're guessing digit j of the quotient (i.e. q0 << j) from
-         * digit bn of the divisor (i.e. bn << (b.data.len() - 1) - so the product of those
-         * two numbers will be zero in all digits up to (j + b.data.len() - 1).
-         */
-        let offset = j + b.data.len() - 1;
-        if offset >= a.data.len() {
-            continue;
-        }
-
-        /* just avoiding a heap allocation: */
-        let mut a0 = tmp;
-        a0.data.truncate(0);
-        a0.data.extend(a.data[offset..].iter().cloned());
-
-        /*
-         * q0 << j * big_digit::BITS is our actual quotient estimate - we do the shifts
-         * implicitly at the end, when adding and subtracting to a and q. Not only do we
-         * save the cost of the shifts, the rest of the arithmetic gets to work with
-         * smaller numbers.
-         */
-        let (mut q0, _) = div_rem_digit(a0, bn);
-        let mut prod = &b * &q0;
-
-        while cmp_slice(&prod.data[..], &a.data[j..]) == Greater {
-            let one: BigUint = One::one();
-            q0 = q0 - one;
-            prod = prod - &b;
-        }
-
-        add2(&mut q.data[j..], &q0.data[..]);
-        sub2(&mut a.data[j..], &prod.data[..]);
-        a = a.normalize();
-
-        tmp = q0;
-    }
-
-    debug_assert!(a < b);
-
-    (q.normalize(), a >> shift)
-}
-
-/// Find last set bit
-/// fls(0) == 0, fls(u32::MAX) == 32
-pub fn fls<T: traits::PrimInt>(v: T) -> usize {
-    mem::size_of::<T>() * 8 - v.leading_zeros() as usize
-}
-
-pub fn ilog2<T: traits::PrimInt>(v: T) -> usize {
-    fls(v) - 1
-}
-
-#[inline]
-pub fn biguint_shl(n: Cow<BigUint>, bits: usize) -> BigUint {
-    let n_unit = bits / big_digit::BITS;
-    let mut data = match n_unit {
-        0 => n.into_owned().data,
-        _ => {
-            let len = n_unit + n.data.len() + 1;
-            let mut data = Vec::with_capacity(len);
-            data.extend(repeat(0).take(n_unit));
-            data.extend(n.data.iter().cloned());
-            data
-        }
-    };
-
-    let n_bits = bits % big_digit::BITS;
-    if n_bits > 0 {
-        let mut carry = 0;
-        for elem in data[n_unit..].iter_mut() {
-            let new_carry = *elem >> (big_digit::BITS - n_bits);
-            *elem = (*elem << n_bits) | carry;
-            carry = new_carry;
-        }
-        if carry != 0 {
-            data.push(carry);
-        }
-    }
-
-    BigUint::new(data)
-}
-
-#[inline]
-pub fn biguint_shr(n: Cow<BigUint>, bits: usize) -> BigUint {
-    let n_unit = bits / big_digit::BITS;
-    if n_unit >= n.data.len() {
-        return Zero::zero();
-    }
-    let mut data = match n_unit {
-        0 => n.into_owned().data,
-        _ => n.data[n_unit..].to_vec(),
-    };
-
-    let n_bits = bits % big_digit::BITS;
-    if n_bits > 0 {
-        let mut borrow = 0;
-        for elem in data.iter_mut().rev() {
-            let new_borrow = *elem << (big_digit::BITS - n_bits);
-            *elem = (*elem >> n_bits) | borrow;
-            borrow = new_borrow;
-        }
-    }
-
-    BigUint::new(data)
-}
-
-pub fn cmp_slice(a: &[BigDigit], b: &[BigDigit]) -> Ordering {
-    debug_assert!(a.last() != Some(&0));
-    debug_assert!(b.last() != Some(&0));
-
-    let (a_len, b_len) = (a.len(), b.len());
-    if a_len < b_len {
-        return Less;
-    }
-    if a_len > b_len {
-        return Greater;
-    }
-
-    for (&ai, &bi) in a.iter().rev().zip(b.iter().rev()) {
-        if ai < bi {
-            return Less;
-        }
-        if ai > bi {
-            return Greater;
-        }
-    }
-    return Equal;
-}
-
-#[cfg(test)]
-mod algorithm_tests {
-    use {BigDigit, BigUint, BigInt};
-    use Sign::Plus;
-    use traits::Num;
-
-    #[test]
-    fn test_sub_sign() {
-        use super::sub_sign;
-
-        fn sub_sign_i(a: &[BigDigit], b: &[BigDigit]) -> BigInt {
-            let (sign, val) = sub_sign(a, b);
-            BigInt::from_biguint(sign, val)
-        }
-
-        let a = BigUint::from_str_radix("265252859812191058636308480000000", 10).unwrap();
-        let b = BigUint::from_str_radix("26525285981219105863630848000000", 10).unwrap();
-        let a_i = BigInt::from_biguint(Plus, a.clone());
-        let b_i = BigInt::from_biguint(Plus, b.clone());
-
-        assert_eq!(sub_sign_i(&a.data[..], &b.data[..]), &a_i - &b_i);
-        assert_eq!(sub_sign_i(&b.data[..], &a.data[..]), &b_i - &a_i);
-    }
-}

bigint/src/lib.rs

@@ -1,139 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! A Big integer (signed version: `BigInt`, unsigned version: `BigUint`).
-//!
-//! A `BigUint` is represented as a vector of `BigDigit`s.
-//! A `BigInt` is a combination of `BigUint` and `Sign`.
-//!
-//! Common numerical operations are overloaded, so we can treat them
-//! the same way we treat other numbers.
-//!
-//! ## Example
-//!
-//! ```rust
-//! extern crate num_bigint;
-//! extern crate num_traits;
-//!
-//! # fn main() {
-//! use num_bigint::BigUint;
-//! use num_traits::{Zero, One};
-//! use std::mem::replace;
-//!
-//! // Calculate large fibonacci numbers.
-//! fn fib(n: usize) -> BigUint {
-//!     let mut f0: BigUint = Zero::zero();
-//!     let mut f1: BigUint = One::one();
-//!     for _ in 0..n {
-//!         let f2 = f0 + &f1;
-//!         // This is a low cost way of swapping f0 with f1 and f1 with f2.
-//!         f0 = replace(&mut f1, f2);
-//!     }
-//!     f0
-//! }
-//!
-//! // This is a very large number.
-//! println!("fib(1000) = {}", fib(1000));
-//! # }
-//! ```
-//!
-//! It's easy to generate large random numbers:
-//!
-//! ```rust
-//! extern crate rand;
-//! extern crate num_bigint as bigint;
-//!
-//! # #[cfg(feature = "rand")]
-//! # fn main() {
-//! use bigint::{ToBigInt, RandBigInt};
-//!
-//! let mut rng = rand::thread_rng();
-//! let a = rng.gen_bigint(1000);
-//!
-//! let low = -10000.to_bigint().unwrap();
-//! let high = 10000.to_bigint().unwrap();
-//! let b = rng.gen_bigint_range(&low, &high);
-//!
-//! // Probably an even larger number.
-//! println!("{}", a * b);
-//! # }
-//!
-//! # #[cfg(not(feature = "rand"))]
-//! # fn main() {
-//! # }
-//! ```
-
-#[cfg(any(feature = "rand", test))]
-extern crate rand;
-#[cfg(feature = "rustc-serialize")]
-extern crate rustc_serialize;
-#[cfg(feature = "serde")]
-extern crate serde;
-
-extern crate num_integer as integer;
-extern crate num_traits as traits;
-
-use std::error::Error;
-use std::num::ParseIntError;
-use std::fmt;
-
-#[derive(Debug, PartialEq)]
-pub enum ParseBigIntError {
-    ParseInt(ParseIntError),
-    Other,
-}
-
-impl fmt::Display for ParseBigIntError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            &ParseBigIntError::ParseInt(ref e) => e.fmt(f),
-            &ParseBigIntError::Other => "failed to parse provided string".fmt(f),
-        }
-    }
-}
-
-impl Error for ParseBigIntError {
-    fn description(&self) -> &str {
-        "failed to parse bigint/biguint"
-    }
-}
-
-impl From<ParseIntError> for ParseBigIntError {
-    fn from(err: ParseIntError) -> ParseBigIntError {
-        ParseBigIntError::ParseInt(err)
-    }
-}
-
-#[cfg(test)]
-use std::hash;
-
-#[cfg(test)]
-fn hash<T: hash::Hash>(x: &T) -> u64 {
-    use std::hash::Hasher;
-    let mut hasher = hash::SipHasher::new();
-    x.hash(&mut hasher);
-    hasher.finish()
-}
-
-#[macro_use]
-mod macros;
-
-mod biguint;
-mod bigint;
-
-pub use biguint::BigUint;
-pub use biguint::ToBigUint;
-pub use biguint::big_digit;
-pub use biguint::big_digit::{BigDigit, DoubleBigDigit, ZERO_BIG_DIGIT};
-
-pub use bigint::Sign;
-pub use bigint::BigInt;
-pub use bigint::ToBigInt;
-pub use bigint::RandBigInt;

bigint/src/macros.rs

@@ -1,133 +0,0 @@
-
-macro_rules! forward_val_val_binop {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        impl $imp<$res> for $res {
-            type Output = $res;
-
-            #[inline]
-            fn $method(self, other: $res) -> $res {
-                // forward to val-ref
-                $imp::$method(self, &other)
-            }
-        }
-    }
-}
-
-macro_rules! forward_val_val_binop_commutative {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        impl $imp<$res> for $res {
-            type Output = $res;
-
-            #[inline]
-            fn $method(self, other: $res) -> $res {
-                // forward to val-ref, with the larger capacity as val
-                if self.data.capacity() >= other.data.capacity() {
-                    $imp::$method(self, &other)
-                } else {
-                    $imp::$method(other, &self)
-                }
-            }
-        }
-    }
-}
-
-macro_rules! forward_ref_val_binop {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        impl<'a> $imp<$res> for &'a $res {
-            type Output = $res;
-
-            #[inline]
-            fn $method(self, other: $res) -> $res {
-                // forward to ref-ref
-                $imp::$method(self, &other)
-            }
-        }
-    }
-}
-
-macro_rules! forward_ref_val_binop_commutative {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        impl<'a> $imp<$res> for &'a $res {
-            type Output = $res;
-
-            #[inline]
-            fn $method(self, other: $res) -> $res {
-                // reverse, forward to val-ref
-                $imp::$method(other, self)
-            }
-        }
-    }
-}
-
-macro_rules! forward_val_ref_binop {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        impl<'a> $imp<&'a $res> for $res {
-            type Output = $res;
-
-            #[inline]
-            fn $method(self, other: &$res) -> $res {
-                // forward to ref-ref
-                $imp::$method(&self, other)
-            }
-        }
-    }
-}
-
-macro_rules! forward_ref_ref_binop {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        impl<'a, 'b> $imp<&'b $res> for &'a $res {
-            type Output = $res;
-
-            #[inline]
-            fn $method(self, other: &$res) -> $res {
-                // forward to val-ref
-                $imp::$method(self.clone(), other)
-            }
-        }
-    }
-}
-
-macro_rules! forward_ref_ref_binop_commutative {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        impl<'a, 'b> $imp<&'b $res> for &'a $res {
-            type Output = $res;
-
-            #[inline]
-            fn $method(self, other: &$res) -> $res {
-                // forward to val-ref, choosing the larger to clone
-                if self.data.len() >= other.data.len() {
-                    $imp::$method(self.clone(), other)
-                } else {
-                    $imp::$method(other.clone(), self)
-                }
-            }
-        }
-    }
-}
-
-// Forward everything to ref-ref, when reusing storage is not helpful
-macro_rules! forward_all_binop_to_ref_ref {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        forward_val_val_binop!(impl $imp for $res, $method);
-        forward_val_ref_binop!(impl $imp for $res, $method);
-        forward_ref_val_binop!(impl $imp for $res, $method);
-    };
-}
-
-// Forward everything to val-ref, so LHS storage can be reused
-macro_rules! forward_all_binop_to_val_ref {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        forward_val_val_binop!(impl $imp for $res, $method);
-        forward_ref_val_binop!(impl $imp for $res, $method);
-        forward_ref_ref_binop!(impl $imp for $res, $method);
-    };
-}
-
-// Forward everything to val-ref, commutatively, so either LHS or RHS storage can be reused
-macro_rules! forward_all_binop_to_val_ref_commutative {
-    (impl $imp:ident for $res:ty, $method:ident) => {
-        forward_val_val_binop_commutative!(impl $imp for $res, $method);
-        forward_ref_val_binop_commutative!(impl $imp for $res, $method);
-        forward_ref_ref_binop_commutative!(impl $imp for $res, $method);
-    };
-}

bigint/src/tests/bigint.rs

@@ -1,954 +0,0 @@
-use {BigDigit, BigUint, big_digit};
-use {Sign, BigInt, RandBigInt, ToBigInt};
-use Sign::{Minus, NoSign, Plus};
-
-use std::cmp::Ordering::{Less, Equal, Greater};
-use std::{f32, f64};
-use std::{i8, i16, i32, i64, isize};
-use std::iter::repeat;
-use std::{u8, u16, u32, u64, usize};
-use std::ops::Neg;
-
-use rand::thread_rng;
-
-use integer::Integer;
-use traits::{Zero, One, Signed, ToPrimitive, FromPrimitive, Num, Float};
-
-/// Assert that an op works for all val/ref combinations
-macro_rules! assert_op {
-    ($left:ident $op:tt $right:ident == $expected:expr) => {
-        assert_eq!((&$left) $op (&$right), $expected);
-        assert_eq!((&$left) $op $right.clone(), $expected);
-        assert_eq!($left.clone() $op (&$right), $expected);
-        assert_eq!($left.clone() $op $right.clone(), $expected);
-    };
-}
-
-#[test]
-fn test_from_biguint() {
-    fn check(inp_s: Sign, inp_n: usize, ans_s: Sign, ans_n: usize) {
-        let inp = BigInt::from_biguint(inp_s, FromPrimitive::from_usize(inp_n).unwrap());
-        let ans = BigInt {
-            sign: ans_s,
-            data: FromPrimitive::from_usize(ans_n).unwrap(),
-        };
-        assert_eq!(inp, ans);
-    }
-    check(Plus, 1, Plus, 1);
-    check(Plus, 0, NoSign, 0);
-    check(Minus, 1, Minus, 1);
-    check(NoSign, 1, NoSign, 0);
-}
-
-#[test]
-fn test_from_bytes_be() {
-    fn check(s: &str, result: &str) {
-        assert_eq!(BigInt::from_bytes_be(Plus, s.as_bytes()),
-                   BigInt::parse_bytes(result.as_bytes(), 10).unwrap());
-    }
-    check("A", "65");
-    check("AA", "16705");
-    check("AB", "16706");
-    check("Hello world!", "22405534230753963835153736737");
-    assert_eq!(BigInt::from_bytes_be(Plus, &[]), Zero::zero());
-    assert_eq!(BigInt::from_bytes_be(Minus, &[]), Zero::zero());
-}
-
-#[test]
-fn test_to_bytes_be() {
-    fn check(s: &str, result: &str) {
-        let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
-        let (sign, v) = b.to_bytes_be();
-        assert_eq!((Plus, s.as_bytes()), (sign, &*v));
-    }
-    check("A", "65");
-    check("AA", "16705");
-    check("AB", "16706");
-    check("Hello world!", "22405534230753963835153736737");
-    let b: BigInt = Zero::zero();
-    assert_eq!(b.to_bytes_be(), (NoSign, vec![0]));
-
-    // Test with leading/trailing zero bytes and a full BigDigit of value 0
-    let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap();
-    assert_eq!(b.to_bytes_be(), (Plus, vec![1, 0, 0, 0, 0, 0, 0, 2, 0]));
-}
-
-#[test]
-fn test_from_bytes_le() {
-    fn check(s: &str, result: &str) {
-        assert_eq!(BigInt::from_bytes_le(Plus, s.as_bytes()),
-                   BigInt::parse_bytes(result.as_bytes(), 10).unwrap());
-    }
-    check("A", "65");
-    check("AA", "16705");
-    check("BA", "16706");
-    check("!dlrow olleH", "22405534230753963835153736737");
-    assert_eq!(BigInt::from_bytes_le(Plus, &[]), Zero::zero());
-    assert_eq!(BigInt::from_bytes_le(Minus, &[]), Zero::zero());
-}
-
-#[test]
-fn test_to_bytes_le() {
-    fn check(s: &str, result: &str) {
-        let b = BigInt::parse_bytes(result.as_bytes(), 10).unwrap();
-        let (sign, v) = b.to_bytes_le();
-        assert_eq!((Plus, s.as_bytes()), (sign, &*v));
-    }
-    check("A", "65");
-    check("AA", "16705");
-    check("BA", "16706");
-    check("!dlrow olleH", "22405534230753963835153736737");
-    let b: BigInt = Zero::zero();
-    assert_eq!(b.to_bytes_le(), (NoSign, vec![0]));
-
-    // Test with leading/trailing zero bytes and a full BigDigit of value 0
-    let b = BigInt::from_str_radix("00010000000000000200", 16).unwrap();
-    assert_eq!(b.to_bytes_le(), (Plus, vec![0, 2, 0, 0, 0, 0, 0, 0, 1]));
-}
-
-#[test]
-fn test_cmp() {
-    let vs: [&[BigDigit]; 4] = [&[2 as BigDigit], &[1, 1], &[2, 1], &[1, 1, 1]];
-    let mut nums = Vec::new();
-    for s in vs.iter().rev() {
-        nums.push(BigInt::from_slice(Minus, *s));
-    }
-    nums.push(Zero::zero());
-    nums.extend(vs.iter().map(|s| BigInt::from_slice(Plus, *s)));
-
-    for (i, ni) in nums.iter().enumerate() {
-        for (j0, nj) in nums[i..].iter().enumerate() {
-            let j = i + j0;
-            if i == j {
-                assert_eq!(ni.cmp(nj), Equal);
-                assert_eq!(nj.cmp(ni), Equal);
-                assert_eq!(ni, nj);
-                assert!(!(ni != nj));
-                assert!(ni <= nj);
-                assert!(ni >= nj);
-                assert!(!(ni < nj));
-                assert!(!(ni > nj));
-            } else {
-                assert_eq!(ni.cmp(nj), Less);
-                assert_eq!(nj.cmp(ni), Greater);
-
-                assert!(!(ni == nj));
-                assert!(ni != nj);
-
-                assert!(ni <= nj);
-                assert!(!(ni >= nj));
-                assert!(ni < nj);
-                assert!(!(ni > nj));
-
-                assert!(!(nj <= ni));
-                assert!(nj >= ni);
-                assert!(!(nj < ni));
-                assert!(nj > ni);
-            }
-        }
-    }
-}
-
-
-#[test]
-fn test_hash() {
-    use hash;
-
-    let a = BigInt::new(NoSign, vec![]);
-    let b = BigInt::new(NoSign, vec![0]);
-    let c = BigInt::new(Plus, vec![1]);
-    let d = BigInt::new(Plus, vec![1, 0, 0, 0, 0, 0]);
-    let e = BigInt::new(Plus, vec![0, 0, 0, 0, 0, 1]);
-    let f = BigInt::new(Minus, vec![1]);
-    assert!(hash(&a) == hash(&b));
-    assert!(hash(&b) != hash(&c));
-    assert!(hash(&c) == hash(&d));
-    assert!(hash(&d) != hash(&e));
-    assert!(hash(&c) != hash(&f));
-}
-
-#[test]
-fn test_convert_i64() {
-    fn check(b1: BigInt, i: i64) {
-        let b2: BigInt = FromPrimitive::from_i64(i).unwrap();
-        assert!(b1 == b2);
-        assert!(b1.to_i64().unwrap() == i);
-    }
-
-    check(Zero::zero(), 0);
-    check(One::one(), 1);
-    check(i64::MIN.to_bigint().unwrap(), i64::MIN);
-    check(i64::MAX.to_bigint().unwrap(), i64::MAX);
-
-    assert_eq!((i64::MAX as u64 + 1).to_bigint().unwrap().to_i64(), None);
-
-    assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(),
-               None);
-
-    assert_eq!(BigInt::from_biguint(Minus,
-                                    BigUint::new(vec![1, 0, 0, 1 << (big_digit::BITS - 1)]))
-                   .to_i64(),
-               None);
-
-    assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_i64(),
-               None);
-}
-
-#[test]
-fn test_convert_u64() {
-    fn check(b1: BigInt, u: u64) {
-        let b2: BigInt = FromPrimitive::from_u64(u).unwrap();
-        assert!(b1 == b2);
-        assert!(b1.to_u64().unwrap() == u);
-    }
-
-    check(Zero::zero(), 0);
-    check(One::one(), 1);
-    check(u64::MIN.to_bigint().unwrap(), u64::MIN);
-    check(u64::MAX.to_bigint().unwrap(), u64::MAX);
-
-    assert_eq!(BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(),
-               None);
-
-    let max_value: BigUint = FromPrimitive::from_u64(u64::MAX).unwrap();
-    assert_eq!(BigInt::from_biguint(Minus, max_value).to_u64(), None);
-    assert_eq!(BigInt::from_biguint(Minus, BigUint::new(vec![1, 2, 3, 4, 5])).to_u64(),
-               None);
-}
-
-#[test]
-fn test_convert_f32() {
-    fn check(b1: &BigInt, f: f32) {
-        let b2 = BigInt::from_f32(f).unwrap();
-        assert_eq!(b1, &b2);
-        assert_eq!(b1.to_f32().unwrap(), f);
-        let neg_b1 = -b1;
-        let neg_b2 = BigInt::from_f32(-f).unwrap();
-        assert_eq!(neg_b1, neg_b2);
-        assert_eq!(neg_b1.to_f32().unwrap(), -f);
-    }
-
-    check(&BigInt::zero(), 0.0);
-    check(&BigInt::one(), 1.0);
-    check(&BigInt::from(u16::MAX), 2.0.powi(16) - 1.0);
-    check(&BigInt::from(1u64 << 32), 2.0.powi(32));
-    check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64));
-    check(&((BigInt::one() << 100) + (BigInt::one() << 123)),
-          2.0.powi(100) + 2.0.powi(123));
-    check(&(BigInt::one() << 127), 2.0.powi(127));
-    check(&(BigInt::from((1u64 << 24) - 1) << (128 - 24)), f32::MAX);
-
-    // keeping all 24 digits with the bits at different offsets to the BigDigits
-    let x: u32 = 0b00000000101111011111011011011101;
-    let mut f = x as f32;
-    let mut b = BigInt::from(x);
-    for _ in 0..64 {
-        check(&b, f);
-        f *= 2.0;
-        b = b << 1;
-    }
-
-    // this number when rounded to f64 then f32 isn't the same as when rounded straight to f32
-    let mut n: i64 = 0b0000000000111111111111111111111111011111111111111111111111111111;
-    assert!((n as f64) as f32 != n as f32);
-    assert_eq!(BigInt::from(n).to_f32(), Some(n as f32));
-    n = -n;
-    assert!((n as f64) as f32 != n as f32);
-    assert_eq!(BigInt::from(n).to_f32(), Some(n as f32));
-
-    // test rounding up with the bits at different offsets to the BigDigits
-    let mut f = ((1u64 << 25) - 1) as f32;
-    let mut b = BigInt::from(1u64 << 25);
-    for _ in 0..64 {
-        assert_eq!(b.to_f32(), Some(f));
-        f *= 2.0;
-        b = b << 1;
-    }
-
-    // rounding
-    assert_eq!(BigInt::from_f32(-f32::consts::PI),
-               Some(BigInt::from(-3i32)));
-    assert_eq!(BigInt::from_f32(-f32::consts::E), Some(BigInt::from(-2i32)));
-    assert_eq!(BigInt::from_f32(-0.99999), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f32(-0.5), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f32(-0.0), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE / 2.0),
-               Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f32(f32::MIN_POSITIVE), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f32(0.5), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f32(0.99999), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f32(f32::consts::E), Some(BigInt::from(2u32)));
-    assert_eq!(BigInt::from_f32(f32::consts::PI), Some(BigInt::from(3u32)));
-
-    // special float values
-    assert_eq!(BigInt::from_f32(f32::NAN), None);
-    assert_eq!(BigInt::from_f32(f32::INFINITY), None);
-    assert_eq!(BigInt::from_f32(f32::NEG_INFINITY), None);
-
-    // largest BigInt that will round to a finite f32 value
-    let big_num = (BigInt::one() << 128) - BigInt::one() - (BigInt::one() << (128 - 25));
-    assert_eq!(big_num.to_f32(), Some(f32::MAX));
-    assert_eq!((&big_num + BigInt::one()).to_f32(), None);
-    assert_eq!((-&big_num).to_f32(), Some(f32::MIN));
-    assert_eq!(((-&big_num) - BigInt::one()).to_f32(), None);
-
-    assert_eq!(((BigInt::one() << 128) - BigInt::one()).to_f32(), None);
-    assert_eq!((BigInt::one() << 128).to_f32(), None);
-    assert_eq!((-((BigInt::one() << 128) - BigInt::one())).to_f32(), None);
-    assert_eq!((-(BigInt::one() << 128)).to_f32(), None);
-}
-
-#[test]
-fn test_convert_f64() {
-    fn check(b1: &BigInt, f: f64) {
-        let b2 = BigInt::from_f64(f).unwrap();
-        assert_eq!(b1, &b2);
-        assert_eq!(b1.to_f64().unwrap(), f);
-        let neg_b1 = -b1;
-        let neg_b2 = BigInt::from_f64(-f).unwrap();
-        assert_eq!(neg_b1, neg_b2);
-        assert_eq!(neg_b1.to_f64().unwrap(), -f);
-    }
-
-    check(&BigInt::zero(), 0.0);
-    check(&BigInt::one(), 1.0);
-    check(&BigInt::from(u32::MAX), 2.0.powi(32) - 1.0);
-    check(&BigInt::from(1u64 << 32), 2.0.powi(32));
-    check(&BigInt::from_slice(Plus, &[0, 0, 1]), 2.0.powi(64));
-    check(&((BigInt::one() << 100) + (BigInt::one() << 152)),
-          2.0.powi(100) + 2.0.powi(152));
-    check(&(BigInt::one() << 1023), 2.0.powi(1023));
-    check(&(BigInt::from((1u64 << 53) - 1) << (1024 - 53)), f64::MAX);
-
-    // keeping all 53 digits with the bits at different offsets to the BigDigits
-    let x: u64 = 0b0000000000011110111110110111111101110111101111011111011011011101;
-    let mut f = x as f64;
-    let mut b = BigInt::from(x);
-    for _ in 0..128 {
-        check(&b, f);
-        f *= 2.0;
-        b = b << 1;
-    }
-
-    // test rounding up with the bits at different offsets to the BigDigits
-    let mut f = ((1u64 << 54) - 1) as f64;
-    let mut b = BigInt::from(1u64 << 54);
-    for _ in 0..128 {
-        assert_eq!(b.to_f64(), Some(f));
-        f *= 2.0;
-        b = b << 1;
-    }
-
-    // rounding
-    assert_eq!(BigInt::from_f64(-f64::consts::PI),
-               Some(BigInt::from(-3i32)));
-    assert_eq!(BigInt::from_f64(-f64::consts::E), Some(BigInt::from(-2i32)));
-    assert_eq!(BigInt::from_f64(-0.99999), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f64(-0.5), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f64(-0.0), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE / 2.0),
-               Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f64(f64::MIN_POSITIVE), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f64(0.5), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f64(0.99999), Some(BigInt::zero()));
-    assert_eq!(BigInt::from_f64(f64::consts::E), Some(BigInt::from(2u32)));
-    assert_eq!(BigInt::from_f64(f64::consts::PI), Some(BigInt::from(3u32)));
-
-    // special float values
-    assert_eq!(BigInt::from_f64(f64::NAN), None);
-    assert_eq!(BigInt::from_f64(f64::INFINITY), None);
-    assert_eq!(BigInt::from_f64(f64::NEG_INFINITY), None);
-
-    // largest BigInt that will round to a finite f64 value
-    let big_num = (BigInt::one() << 1024) - BigInt::one() - (BigInt::one() << (1024 - 54));
-    assert_eq!(big_num.to_f64(), Some(f64::MAX));
-    assert_eq!((&big_num + BigInt::one()).to_f64(), None);
-    assert_eq!((-&big_num).to_f64(), Some(f64::MIN));
-    assert_eq!(((-&big_num) - BigInt::one()).to_f64(), None);
-
-    assert_eq!(((BigInt::one() << 1024) - BigInt::one()).to_f64(), None);
-    assert_eq!((BigInt::one() << 1024).to_f64(), None);
-    assert_eq!((-((BigInt::one() << 1024) - BigInt::one())).to_f64(), None);
-    assert_eq!((-(BigInt::one() << 1024)).to_f64(), None);
-}
-
-#[test]
-fn test_convert_to_biguint() {
-    fn check(n: BigInt, ans_1: BigUint) {
-        assert_eq!(n.to_biguint().unwrap(), ans_1);
-        assert_eq!(n.to_biguint().unwrap().to_bigint().unwrap(), n);
-    }
-    let zero: BigInt = Zero::zero();
-    let unsigned_zero: BigUint = Zero::zero();
-    let positive = BigInt::from_biguint(Plus, BigUint::new(vec![1, 2, 3]));
-    let negative = -&positive;
-
-    check(zero, unsigned_zero);
-    check(positive, BigUint::new(vec![1, 2, 3]));
-
-    assert_eq!(negative.to_biguint(), None);
-}
-
-#[test]
-fn test_convert_from_uint() {
-    macro_rules! check {
-        ($ty:ident, $max:expr) => {
-            assert_eq!(BigInt::from($ty::zero()), BigInt::zero());
-            assert_eq!(BigInt::from($ty::one()), BigInt::one());
-            assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one());
-            assert_eq!(BigInt::from($ty::MAX), $max);
-        }
-    }
-
-    check!(u8, BigInt::from_slice(Plus, &[u8::MAX as BigDigit]));
-    check!(u16, BigInt::from_slice(Plus, &[u16::MAX as BigDigit]));
-    check!(u32, BigInt::from_slice(Plus, &[u32::MAX as BigDigit]));
-    check!(u64,
-           BigInt::from_slice(Plus, &[u32::MAX as BigDigit, u32::MAX as BigDigit]));
-    check!(usize, BigInt::from(usize::MAX as u64));
-}
-
-#[test]
-fn test_convert_from_int() {
-    macro_rules! check {
-        ($ty:ident, $min:expr, $max:expr) => {
-            assert_eq!(BigInt::from($ty::MIN), $min);
-            assert_eq!(BigInt::from($ty::MIN + $ty::one()), $min + BigInt::one());
-            assert_eq!(BigInt::from(-$ty::one()), -BigInt::one());
-            assert_eq!(BigInt::from($ty::zero()), BigInt::zero());
-            assert_eq!(BigInt::from($ty::one()), BigInt::one());
-            assert_eq!(BigInt::from($ty::MAX - $ty::one()), $max - BigInt::one());
-            assert_eq!(BigInt::from($ty::MAX), $max);
-        }
-    }
-
-    check!(i8,
-           BigInt::from_slice(Minus, &[1 << 7]),
-           BigInt::from_slice(Plus, &[i8::MAX as BigDigit]));
-    check!(i16,
-           BigInt::from_slice(Minus, &[1 << 15]),
-           BigInt::from_slice(Plus, &[i16::MAX as BigDigit]));
-    check!(i32,
-           BigInt::from_slice(Minus, &[1 << 31]),
-           BigInt::from_slice(Plus, &[i32::MAX as BigDigit]));
-    check!(i64,
-           BigInt::from_slice(Minus, &[0, 1 << 31]),
-           BigInt::from_slice(Plus, &[u32::MAX as BigDigit, i32::MAX as BigDigit]));
-    check!(isize,
-           BigInt::from(isize::MIN as i64),
-           BigInt::from(isize::MAX as i64));
-}
-
-#[test]
-fn test_convert_from_biguint() {
-    assert_eq!(BigInt::from(BigUint::zero()), BigInt::zero());
-    assert_eq!(BigInt::from(BigUint::one()), BigInt::one());
-    assert_eq!(BigInt::from(BigUint::from_slice(&[1, 2, 3])),
-               BigInt::from_slice(Plus, &[1, 2, 3]));
-}
-
-const N1: BigDigit = -1i32 as BigDigit;
-const N2: BigDigit = -2i32 as BigDigit;
-
-const SUM_TRIPLES: &'static [(&'static [BigDigit],
-           &'static [BigDigit],
-           &'static [BigDigit])] = &[(&[], &[], &[]),
-                                     (&[], &[1], &[1]),
-                                     (&[1], &[1], &[2]),
-                                     (&[1], &[1, 1], &[2, 1]),
-                                     (&[1], &[N1], &[0, 1]),
-                                     (&[1], &[N1, N1], &[0, 0, 1]),
-                                     (&[N1, N1], &[N1, N1], &[N2, N1, 1]),
-                                     (&[1, 1, 1], &[N1, N1], &[0, 1, 2]),
-                                     (&[2, 2, 1], &[N1, N2], &[1, 1, 2])];
-
-#[test]
-fn test_add() {
-    for elm in SUM_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-        let (na, nb, nc) = (-&a, -&b, -&c);
-
-        assert_op!(a + b == c);
-        assert_op!(b + a == c);
-        assert_op!(c + na == b);
-        assert_op!(c + nb == a);
-        assert_op!(a + nc == nb);
-        assert_op!(b + nc == na);
-        assert_op!(na + nb == nc);
-        assert_op!(a + na == Zero::zero());
-    }
-}
-
-#[test]
-fn test_sub() {
-    for elm in SUM_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-        let (na, nb, nc) = (-&a, -&b, -&c);
-
-        assert_op!(c - a == b);
-        assert_op!(c - b == a);
-        assert_op!(nb - a == nc);
-        assert_op!(na - b == nc);
-        assert_op!(b - na == c);
-        assert_op!(a - nb == c);
-        assert_op!(nc - na == nb);
-        assert_op!(a - a == Zero::zero());
-    }
-}
-
-const M: u32 = ::std::u32::MAX;
-static MUL_TRIPLES: &'static [(&'static [BigDigit],
-           &'static [BigDigit],
-           &'static [BigDigit])] = &[(&[], &[], &[]),
-                                     (&[], &[1], &[]),
-                                     (&[2], &[], &[]),
-                                     (&[1], &[1], &[1]),
-                                     (&[2], &[3], &[6]),
-                                     (&[1], &[1, 1, 1], &[1, 1, 1]),
-                                     (&[1, 2, 3], &[3], &[3, 6, 9]),
-                                     (&[1, 1, 1], &[N1], &[N1, N1, N1]),
-                                     (&[1, 2, 3], &[N1], &[N1, N2, N2, 2]),
-                                     (&[1, 2, 3, 4], &[N1], &[N1, N2, N2, N2, 3]),
-                                     (&[N1], &[N1], &[1, N2]),
-                                     (&[N1, N1], &[N1], &[1, N1, N2]),
-                                     (&[N1, N1, N1], &[N1], &[1, N1, N1, N2]),
-                                     (&[N1, N1, N1, N1], &[N1], &[1, N1, N1, N1, N2]),
-                                     (&[M / 2 + 1], &[2], &[0, 1]),
-                                     (&[0, M / 2 + 1], &[2], &[0, 0, 1]),
-                                     (&[1, 2], &[1, 2, 3], &[1, 4, 7, 6]),
-                                     (&[N1, N1], &[N1, N1, N1], &[1, 0, N1, N2, N1]),
-                                     (&[N1, N1, N1],
-                                      &[N1, N1, N1, N1],
-                                      &[1, 0, 0, N1, N2, N1, N1]),
-                                     (&[0, 0, 1], &[1, 2, 3], &[0, 0, 1, 2, 3]),
-                                     (&[0, 0, 1], &[0, 0, 0, 1], &[0, 0, 0, 0, 0, 1])];
-
-static DIV_REM_QUADRUPLES: &'static [(&'static [BigDigit],
-           &'static [BigDigit],
-           &'static [BigDigit],
-           &'static [BigDigit])] = &[(&[1], &[2], &[], &[1]),
-                                     (&[1, 1], &[2], &[M / 2 + 1], &[1]),
-                                     (&[1, 1, 1], &[2], &[M / 2 + 1, M / 2 + 1], &[1]),
-                                     (&[0, 1], &[N1], &[1], &[1]),
-                                     (&[N1, N1], &[N2], &[2, 1], &[3])];
-
-#[test]
-fn test_mul() {
-    for elm in MUL_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-        let (na, nb, nc) = (-&a, -&b, -&c);
-
-        assert_op!(a * b == c);
-        assert_op!(b * a == c);
-        assert_op!(na * nb == c);
-
-        assert_op!(na * b == nc);
-        assert_op!(nb * a == nc);
-    }
-
-    for elm in DIV_REM_QUADRUPLES.iter() {
-        let (a_vec, b_vec, c_vec, d_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-        let d = BigInt::from_slice(Plus, d_vec);
-
-        assert!(a == &b * &c + &d);
-        assert!(a == &c * &b + &d);
-    }
-}
-
-#[test]
-fn test_div_mod_floor() {
-    fn check_sub(a: &BigInt, b: &BigInt, ans_d: &BigInt, ans_m: &BigInt) {
-        let (d, m) = a.div_mod_floor(b);
-        if !m.is_zero() {
-            assert_eq!(m.sign, b.sign);
-        }
-        assert!(m.abs() <= b.abs());
-        assert!(*a == b * &d + &m);
-        assert!(d == *ans_d);
-        assert!(m == *ans_m);
-    }
-
-    fn check(a: &BigInt, b: &BigInt, d: &BigInt, m: &BigInt) {
-        if m.is_zero() {
-            check_sub(a, b, d, m);
-            check_sub(a, &b.neg(), &d.neg(), m);
-            check_sub(&a.neg(), b, &d.neg(), m);
-            check_sub(&a.neg(), &b.neg(), d, m);
-        } else {
-            let one: BigInt = One::one();
-            check_sub(a, b, d, m);
-            check_sub(a, &b.neg(), &(d.neg() - &one), &(m - b));
-            check_sub(&a.neg(), b, &(d.neg() - &one), &(b - m));
-            check_sub(&a.neg(), &b.neg(), d, &m.neg());
-        }
-    }
-
-    for elm in MUL_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-
-        if !a.is_zero() {
-            check(&c, &a, &b, &Zero::zero());
-        }
-        if !b.is_zero() {
-            check(&c, &b, &a, &Zero::zero());
-        }
-    }
-
-    for elm in DIV_REM_QUADRUPLES.iter() {
-        let (a_vec, b_vec, c_vec, d_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-        let d = BigInt::from_slice(Plus, d_vec);
-
-        if !b.is_zero() {
-            check(&a, &b, &c, &d);
-        }
-    }
-}
-
-
-#[test]
-fn test_div_rem() {
-    fn check_sub(a: &BigInt, b: &BigInt, ans_q: &BigInt, ans_r: &BigInt) {
-        let (q, r) = a.div_rem(b);
-        if !r.is_zero() {
-            assert_eq!(r.sign, a.sign);
-        }
-        assert!(r.abs() <= b.abs());
-        assert!(*a == b * &q + &r);
-        assert!(q == *ans_q);
-        assert!(r == *ans_r);
-
-        let (a, b, ans_q, ans_r) = (a.clone(), b.clone(), ans_q.clone(), ans_r.clone());
-        assert_op!(a / b == ans_q);
-        assert_op!(a % b == ans_r);
-    }
-
-    fn check(a: &BigInt, b: &BigInt, q: &BigInt, r: &BigInt) {
-        check_sub(a, b, q, r);
-        check_sub(a, &b.neg(), &q.neg(), r);
-        check_sub(&a.neg(), b, &q.neg(), &r.neg());
-        check_sub(&a.neg(), &b.neg(), q, &r.neg());
-    }
-    for elm in MUL_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-
-        if !a.is_zero() {
-            check(&c, &a, &b, &Zero::zero());
-        }
-        if !b.is_zero() {
-            check(&c, &b, &a, &Zero::zero());
-        }
-    }
-
-    for elm in DIV_REM_QUADRUPLES.iter() {
-        let (a_vec, b_vec, c_vec, d_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-        let d = BigInt::from_slice(Plus, d_vec);
-
-        if !b.is_zero() {
-            check(&a, &b, &c, &d);
-        }
-    }
-}
-
-#[test]
-fn test_checked_add() {
-    for elm in SUM_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-
-        assert!(a.checked_add(&b).unwrap() == c);
-        assert!(b.checked_add(&a).unwrap() == c);
-        assert!(c.checked_add(&(-&a)).unwrap() == b);
-        assert!(c.checked_add(&(-&b)).unwrap() == a);
-        assert!(a.checked_add(&(-&c)).unwrap() == (-&b));
-        assert!(b.checked_add(&(-&c)).unwrap() == (-&a));
-        assert!((-&a).checked_add(&(-&b)).unwrap() == (-&c));
-        assert!(a.checked_add(&(-&a)).unwrap() == Zero::zero());
-    }
-}
-
-#[test]
-fn test_checked_sub() {
-    for elm in SUM_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-
-        assert!(c.checked_sub(&a).unwrap() == b);
-        assert!(c.checked_sub(&b).unwrap() == a);
-        assert!((-&b).checked_sub(&a).unwrap() == (-&c));
-        assert!((-&a).checked_sub(&b).unwrap() == (-&c));
-        assert!(b.checked_sub(&(-&a)).unwrap() == c);
-        assert!(a.checked_sub(&(-&b)).unwrap() == c);
-        assert!((-&c).checked_sub(&(-&a)).unwrap() == (-&b));
-        assert!(a.checked_sub(&a).unwrap() == Zero::zero());
-    }
-}
-
-#[test]
-fn test_checked_mul() {
-    for elm in MUL_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-
-        assert!(a.checked_mul(&b).unwrap() == c);
-        assert!(b.checked_mul(&a).unwrap() == c);
-
-        assert!((-&a).checked_mul(&b).unwrap() == -&c);
-        assert!((-&b).checked_mul(&a).unwrap() == -&c);
-    }
-
-    for elm in DIV_REM_QUADRUPLES.iter() {
-        let (a_vec, b_vec, c_vec, d_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-        let d = BigInt::from_slice(Plus, d_vec);
-
-        assert!(a == b.checked_mul(&c).unwrap() + &d);
-        assert!(a == c.checked_mul(&b).unwrap() + &d);
-    }
-}
-#[test]
-fn test_checked_div() {
-    for elm in MUL_TRIPLES.iter() {
-        let (a_vec, b_vec, c_vec) = *elm;
-        let a = BigInt::from_slice(Plus, a_vec);
-        let b = BigInt::from_slice(Plus, b_vec);
-        let c = BigInt::from_slice(Plus, c_vec);
-
-        if !a.is_zero() {
-            assert!(c.checked_div(&a).unwrap() == b);
-            assert!((-&c).checked_div(&(-&a)).unwrap() == b);
-            assert!((-&c).checked_div(&a).unwrap() == -&b);
-        }
-        if !b.is_zero() {
-            assert!(c.checked_div(&b).unwrap() == a);
-            assert!((-&c).checked_div(&(-&b)).unwrap() == a);
-            assert!((-&c).checked_div(&b).unwrap() == -&a);
-        }
-
-        assert!(c.checked_div(&Zero::zero()).is_none());
-        assert!((-&c).checked_div(&Zero::zero()).is_none());
-    }
-}
-
-#[test]
-fn test_gcd() {
-    fn check(a: isize, b: isize, c: isize) {
-        let big_a: BigInt = FromPrimitive::from_isize(a).unwrap();
-        let big_b: BigInt = FromPrimitive::from_isize(b).unwrap();
-        let big_c: BigInt = FromPrimitive::from_isize(c).unwrap();
-
-        assert_eq!(big_a.gcd(&big_b), big_c);
-    }
-
-    check(10, 2, 2);
-    check(10, 3, 1);
-    check(0, 3, 3);
-    check(3, 3, 3);
-    check(56, 42, 14);
-    check(3, -3, 3);
-    check(-6, 3, 3);
-    check(-4, -2, 2);
-}
-
-#[test]
-fn test_lcm() {
-    fn check(a: isize, b: isize, c: isize) {
-        let big_a: BigInt = FromPrimitive::from_isize(a).unwrap();
-        let big_b: BigInt = FromPrimitive::from_isize(b).unwrap();
-        let big_c: BigInt = FromPrimitive::from_isize(c).unwrap();
-
-        assert_eq!(big_a.lcm(&big_b), big_c);
-    }
-
-    check(1, 0, 0);
-    check(0, 1, 0);
-    check(1, 1, 1);
-    check(-1, 1, 1);
-    check(1, -1, 1);
-    check(-1, -1, 1);
-    check(8, 9, 72);
-    check(11, 5, 55);
-}
-
-#[test]
-fn test_abs_sub() {
-    let zero: BigInt = Zero::zero();
-    let one: BigInt = One::one();
-    assert_eq!((-&one).abs_sub(&one), zero);
-    let one: BigInt = One::one();
-    let zero: BigInt = Zero::zero();
-    assert_eq!(one.abs_sub(&one), zero);
-    let one: BigInt = One::one();
-    let zero: BigInt = Zero::zero();
-    assert_eq!(one.abs_sub(&zero), one);
-    let one: BigInt = One::one();
-    let two: BigInt = FromPrimitive::from_isize(2).unwrap();
-    assert_eq!(one.abs_sub(&-&one), two);
-}
-
-#[test]
-fn test_from_str_radix() {
-    fn check(s: &str, ans: Option<isize>) {
-        let ans = ans.map(|n| {
-            let x: BigInt = FromPrimitive::from_isize(n).unwrap();
-            x
-        });
-        assert_eq!(BigInt::from_str_radix(s, 10).ok(), ans);
-    }
-    check("10", Some(10));
-    check("1", Some(1));
-    check("0", Some(0));
-    check("-1", Some(-1));
-    check("-10", Some(-10));
-    check("+10", Some(10));
-    check("--7", None);
-    check("++5", None);
-    check("+-9", None);
-    check("-+3", None);
-    check("Z", None);
-    check("_", None);
-
-    // issue 10522, this hit an edge case that caused it to
-    // attempt to allocate a vector of size (-1u) == huge.
-    let x: BigInt = format!("1{}", repeat("0").take(36).collect::<String>()).parse().unwrap();
-    let _y = x.to_string();
-}
-
-#[test]
-fn test_lower_hex() {
-    let a = BigInt::parse_bytes(b"A", 16).unwrap();
-    let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
-
-    assert_eq!(format!("{:x}", a), "a");
-    assert_eq!(format!("{:x}", hello), "-48656c6c6f20776f726c6421");
-    assert_eq!(format!("{:♥>+#8x}", a), "♥♥♥♥+0xa");
-}
-
-#[test]
-fn test_upper_hex() {
-    let a = BigInt::parse_bytes(b"A", 16).unwrap();
-    let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
-
-    assert_eq!(format!("{:X}", a), "A");
-    assert_eq!(format!("{:X}", hello), "-48656C6C6F20776F726C6421");
-    assert_eq!(format!("{:♥>+#8X}", a), "♥♥♥♥+0xA");
-}
-
-#[test]
-fn test_binary() {
-    let a = BigInt::parse_bytes(b"A", 16).unwrap();
-    let hello = BigInt::parse_bytes("-224055342307539".as_bytes(), 10).unwrap();
-
-    assert_eq!(format!("{:b}", a), "1010");
-    assert_eq!(format!("{:b}", hello),
-               "-110010111100011011110011000101101001100011010011");
-    assert_eq!(format!("{:♥>+#8b}", a), "♥+0b1010");
-}
-
-#[test]
-fn test_octal() {
-    let a = BigInt::parse_bytes(b"A", 16).unwrap();
-    let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
-
-    assert_eq!(format!("{:o}", a), "12");
-    assert_eq!(format!("{:o}", hello), "-22062554330674403566756233062041");
-    assert_eq!(format!("{:♥>+#8o}", a), "♥♥♥+0o12");
-}
-
-#[test]
-fn test_display() {
-    let a = BigInt::parse_bytes(b"A", 16).unwrap();
-    let hello = BigInt::parse_bytes("-22405534230753963835153736737".as_bytes(), 10).unwrap();
-
-    assert_eq!(format!("{}", a), "10");
-    assert_eq!(format!("{}", hello), "-22405534230753963835153736737");
-    assert_eq!(format!("{:♥>+#8}", a), "♥♥♥♥♥+10");
-}
-
-#[test]
-fn test_neg() {
-    assert!(-BigInt::new(Plus, vec![1, 1, 1]) == BigInt::new(Minus, vec![1, 1, 1]));
-    assert!(-BigInt::new(Minus, vec![1, 1, 1]) == BigInt::new(Plus, vec![1, 1, 1]));
-    let zero: BigInt = Zero::zero();
-    assert_eq!(-&zero, zero);
-}
-
-#[test]
-fn test_rand() {
-    let mut rng = thread_rng();
-    let _n: BigInt = rng.gen_bigint(137);
-    assert!(rng.gen_bigint(0).is_zero());
-}
-
-#[test]
-fn test_rand_range() {
-    let mut rng = thread_rng();
-
-    for _ in 0..10 {
-        assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_usize(236).unwrap(),
-                                        &FromPrimitive::from_usize(237).unwrap()),
-                   FromPrimitive::from_usize(236).unwrap());
-    }
-
-    fn check(l: BigInt, u: BigInt) {
-        let mut rng = thread_rng();
-        for _ in 0..1000 {
-            let n: BigInt = rng.gen_bigint_range(&l, &u);
-            assert!(n >= l);
-            assert!(n < u);
-        }
-    }
-    let l: BigInt = FromPrimitive::from_usize(403469000 + 2352).unwrap();
-    let u: BigInt = FromPrimitive::from_usize(403469000 + 3513).unwrap();
-    check(l.clone(), u.clone());
-    check(-l.clone(), u.clone());
-    check(-u.clone(), -l.clone());
-}
-
-#[test]
-#[should_panic]
-fn test_zero_rand_range() {
-    thread_rng().gen_bigint_range(&FromPrimitive::from_isize(54).unwrap(),
-                                  &FromPrimitive::from_isize(54).unwrap());
-}
-
-#[test]
-#[should_panic]
-fn test_negative_rand_range() {
-    let mut rng = thread_rng();
-    let l = FromPrimitive::from_usize(2352).unwrap();
-    let u = FromPrimitive::from_usize(3513).unwrap();
-    // Switching u and l should fail:
-    let _n: BigInt = rng.gen_bigint_range(&u, &l);
-}

bors.toml

@@ -0,0 +1,3 @@
+status = [
+  "continuous-integration/travis-ci/push",
+]

build.rs

@@ -0,0 +1,14 @@
+extern crate autocfg;
+
+use std::env;
+
+fn main() {
+    let ac = autocfg::new();
+    if ac.probe_type("i128") {
+        println!("cargo:rustc-cfg=has_i128");
+    } else if env::var_os("CARGO_FEATURE_I128").is_some() {
+        panic!("i128 support was not detected!");
+    }
+
+    autocfg::rerun_path(file!());
+}

ci/rustup.sh

@@ -0,0 +1,11 @@
+#!/bin/sh
+# Use rustup to locally run the same suite of tests as .travis.yml.
+# (You should first install/update 1.8.0, stable, beta, and nightly.)
+
+set -ex
+
+export TRAVIS_RUST_VERSION
+for TRAVIS_RUST_VERSION in 1.8.0 1.15.0 1.20.0 stable beta nightly; do
+    run="rustup run $TRAVIS_RUST_VERSION"
+    $run $PWD/ci/test_full.sh
+done

ci/test_full.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+set -ex
+
+echo Testing num-traits on rustc ${TRAVIS_RUST_VERSION}
+
+# num-traits should build and test everywhere.
+cargo build --verbose
+cargo test --verbose
+
+# test `no_std`
+cargo build --verbose --no-default-features
+cargo test --verbose --no-default-features
+
+if [[ "$TRAVIS_RUST_VERSION" =~ ^(nightly|beta|stable)$ ]]; then
+    # test `i128`
+    cargo build --verbose --features=i128
+    cargo test --verbose --features=i128
+
+    # test with std and libm (libm build fails on Rust 1.26 and earlier)
+    cargo build --verbose --features "libm"
+    cargo test --verbose --features "libm"
+
+    # test `no_std` with libm (libm build fails on Rust 1.26 and earlier)
+    cargo build --verbose --no-default-features --features "libm"
+    cargo test --verbose --no-default-features --features "libm"
+fi

complex/Cargo.toml

@@ -1,29 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-description = "Complex numbers implementation for Rust"
-documentation = "http://rust-num.github.io/num"
-homepage = "https://github.com/rust-num/num"
-keywords = ["mathematics", "numerics"]
-license = "MIT/Apache-2.0"
-name = "num-complex"
-repository = "https://github.com/rust-num/num"
-version = "0.1.35"
-
-[dependencies]
-
-[dependencies.num-traits]
-optional = false
-path = "../traits"
-version = "0.1.32"
-
-[dependencies.rustc-serialize]
-optional = true
-version = "0.3.19"
-
-[dependencies.serde]
-optional = true
-version = ">= 0.7.0, < 0.9.0"
-
-[features]
-default = ["rustc-serialize"]
-unstable = []

doc/index.html

@@ -1 +0,0 @@
-<meta http-equiv=refresh content=0;url=num/index.html>

integer/Cargo.toml

@@ -1,14 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-description = "Integer traits and functions"
-documentation = "http://rust-num.github.io/num"
-homepage = "https://github.com/rust-num/num"
-keywords = ["mathematics", "numerics"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/rust-num/num"
-name = "num-integer"
-version = "0.1.32"
-
-[dependencies.num-traits]
-path = "../traits"
-version = "0.1.32"

integer/src/lib.rs

@@ -1,690 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Integer trait and functions.
-
-extern crate num_traits as traits;
-
-use traits::{Num, Signed};
-
-pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
-    /// Floored integer division.
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert!(( 8).div_floor(& 3) ==  2);
-    /// assert!(( 8).div_floor(&-3) == -3);
-    /// assert!((-8).div_floor(& 3) == -3);
-    /// assert!((-8).div_floor(&-3) ==  2);
-    ///
-    /// assert!(( 1).div_floor(& 2) ==  0);
-    /// assert!(( 1).div_floor(&-2) == -1);
-    /// assert!((-1).div_floor(& 2) == -1);
-    /// assert!((-1).div_floor(&-2) ==  0);
-    /// ~~~
-    fn div_floor(&self, other: &Self) -> Self;
-
-    /// Floored integer modulo, satisfying:
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// # let n = 1; let d = 1;
-    /// assert!(n.div_floor(&d) * d + n.mod_floor(&d) == n)
-    /// ~~~
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert!(( 8).mod_floor(& 3) ==  2);
-    /// assert!(( 8).mod_floor(&-3) == -1);
-    /// assert!((-8).mod_floor(& 3) ==  1);
-    /// assert!((-8).mod_floor(&-3) == -2);
-    ///
-    /// assert!(( 1).mod_floor(& 2) ==  1);
-    /// assert!(( 1).mod_floor(&-2) == -1);
-    /// assert!((-1).mod_floor(& 2) ==  1);
-    /// assert!((-1).mod_floor(&-2) == -1);
-    /// ~~~
-    fn mod_floor(&self, other: &Self) -> Self;
-
-    /// Greatest Common Divisor (GCD).
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert_eq!(6.gcd(&8), 2);
-    /// assert_eq!(7.gcd(&3), 1);
-    /// ~~~
-    fn gcd(&self, other: &Self) -> Self;
-
-    /// Lowest Common Multiple (LCM).
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert_eq!(7.lcm(&3), 21);
-    /// assert_eq!(2.lcm(&4), 4);
-    /// ~~~
-    fn lcm(&self, other: &Self) -> Self;
-
-    /// Deprecated, use `is_multiple_of` instead.
-    fn divides(&self, other: &Self) -> bool;
-
-    /// Returns `true` if `other` is a multiple of `self`.
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert_eq!(9.is_multiple_of(&3), true);
-    /// assert_eq!(3.is_multiple_of(&9), false);
-    /// ~~~
-    fn is_multiple_of(&self, other: &Self) -> bool;
-
-    /// Returns `true` if the number is even.
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert_eq!(3.is_even(), false);
-    /// assert_eq!(4.is_even(), true);
-    /// ~~~
-    fn is_even(&self) -> bool;
-
-    /// Returns `true` if the number is odd.
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert_eq!(3.is_odd(), true);
-    /// assert_eq!(4.is_odd(), false);
-    /// ~~~
-    fn is_odd(&self) -> bool;
-
-    /// Simultaneous truncated integer division and modulus.
-    /// Returns `(quotient, remainder)`.
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert_eq!(( 8).div_rem( &3), ( 2,  2));
-    /// assert_eq!(( 8).div_rem(&-3), (-2,  2));
-    /// assert_eq!((-8).div_rem( &3), (-2, -2));
-    /// assert_eq!((-8).div_rem(&-3), ( 2, -2));
-    ///
-    /// assert_eq!(( 1).div_rem( &2), ( 0,  1));
-    /// assert_eq!(( 1).div_rem(&-2), ( 0,  1));
-    /// assert_eq!((-1).div_rem( &2), ( 0, -1));
-    /// assert_eq!((-1).div_rem(&-2), ( 0, -1));
-    /// ~~~
-    #[inline]
-    fn div_rem(&self, other: &Self) -> (Self, Self);
-
-    /// Simultaneous floored integer division and modulus.
-    /// Returns `(quotient, remainder)`.
-    ///
-    /// # Examples
-    ///
-    /// ~~~
-    /// # use num_integer::Integer;
-    /// assert_eq!(( 8).div_mod_floor( &3), ( 2,  2));
-    /// assert_eq!(( 8).div_mod_floor(&-3), (-3, -1));
-    /// assert_eq!((-8).div_mod_floor( &3), (-3,  1));
-    /// assert_eq!((-8).div_mod_floor(&-3), ( 2, -2));
-    ///
-    /// assert_eq!(( 1).div_mod_floor( &2), ( 0,  1));
-    /// assert_eq!(( 1).div_mod_floor(&-2), (-1, -1));
-    /// assert_eq!((-1).div_mod_floor( &2), (-1,  1));
-    /// assert_eq!((-1).div_mod_floor(&-2), ( 0, -1));
-    /// ~~~
-    fn div_mod_floor(&self, other: &Self) -> (Self, Self) {
-        (self.div_floor(other), self.mod_floor(other))
-    }
-}
-
-/// Simultaneous integer division and modulus
-#[inline]
-pub fn div_rem<T: Integer>(x: T, y: T) -> (T, T) {
-    x.div_rem(&y)
-}
-/// Floored integer division
-#[inline]
-pub fn div_floor<T: Integer>(x: T, y: T) -> T {
-    x.div_floor(&y)
-}
-/// Floored integer modulus
-#[inline]
-pub fn mod_floor<T: Integer>(x: T, y: T) -> T {
-    x.mod_floor(&y)
-}
-/// Simultaneous floored integer division and modulus
-#[inline]
-pub fn div_mod_floor<T: Integer>(x: T, y: T) -> (T, T) {
-    x.div_mod_floor(&y)
-}
-
-/// Calculates the Greatest Common Divisor (GCD) of the number and `other`. The
-/// result is always positive.
-#[inline(always)]
-pub fn gcd<T: Integer>(x: T, y: T) -> T {
-    x.gcd(&y)
-}
-/// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
-#[inline(always)]
-pub fn lcm<T: Integer>(x: T, y: T) -> T {
-    x.lcm(&y)
-}
-
-macro_rules! impl_integer_for_isize {
-    ($T:ty, $test_mod:ident) => (
-        impl Integer for $T {
-            /// Floored integer division
-            #[inline]
-            fn div_floor(&self, other: &Self) -> Self {
-                // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
-                // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)
-                match self.div_rem(other) {
-                    (d, r) if (r > 0 && *other < 0)
-                           || (r < 0 && *other > 0) => d - 1,
-                    (d, _)                          => d,
-                }
-            }
-
-            /// Floored integer modulo
-            #[inline]
-            fn mod_floor(&self, other: &Self) -> Self {
-                // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
-                // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)
-                match *self % *other {
-                    r if (r > 0 && *other < 0)
-                      || (r < 0 && *other > 0) => r + *other,
-                    r                          => r,
-                }
-            }
-
-            /// Calculates `div_floor` and `mod_floor` simultaneously
-            #[inline]
-            fn div_mod_floor(&self, other: &Self) -> (Self, Self) {
-                // Algorithm from [Daan Leijen. _Division and Modulus for Computer Scientists_,
-                // December 2001](http://research.microsoft.com/pubs/151917/divmodnote-letter.pdf)
-                match self.div_rem(other) {
-                    (d, r) if (r > 0 && *other < 0)
-                           || (r < 0 && *other > 0) => (d - 1, r + *other),
-                    (d, r)                          => (d, r),
-                }
-            }
-
-            /// Calculates the Greatest Common Divisor (GCD) of the number and
-            /// `other`. The result is always positive.
-            #[inline]
-            fn gcd(&self, other: &Self) -> Self {
-                // Use Stein's algorithm
-                let mut m = *self;
-                let mut n = *other;
-                if m == 0 || n == 0 { return (m | n).abs() }
-
-                // find common factors of 2
-                let shift = (m | n).trailing_zeros();
-
-                // The algorithm needs positive numbers, but the minimum value
-                // can't be represented as a positive one.
-                // It's also a power of two, so the gcd can be
-                // calculated by bitshifting in that case
-
-                // Assuming two's complement, the number created by the shift
-                // is positive for all numbers except gcd = abs(min value)
-                // The call to .abs() causes a panic in debug mode
-                if m == Self::min_value() || n == Self::min_value() {
-                    return (1 << shift).abs()
-                }
-
-                // guaranteed to be positive now, rest like unsigned algorithm
-                m = m.abs();
-                n = n.abs();
-
-                // divide n and m by 2 until odd
-                // m inside loop
-                n >>= n.trailing_zeros();
-
-                while m != 0 {
-                    m >>= m.trailing_zeros();
-                    if n > m { ::std::mem::swap(&mut n, &mut m) }
-                    m -= n;
-                }
-
-                n << shift
-            }
-
-            /// Calculates the Lowest Common Multiple (LCM) of the number and
-            /// `other`.
-            #[inline]
-            fn lcm(&self, other: &Self) -> Self {
-                // should not have to recalculate abs
-                (*self * (*other / self.gcd(other))).abs()
-            }
-
-            /// Deprecated, use `is_multiple_of` instead.
-            #[inline]
-            fn divides(&self, other: &Self) -> bool {
-                self.is_multiple_of(other)
-            }
-
-            /// Returns `true` if the number is a multiple of `other`.
-            #[inline]
-            fn is_multiple_of(&self, other: &Self) -> bool {
-                *self % *other == 0
-            }
-
-            /// Returns `true` if the number is divisible by `2`
-            #[inline]
-            fn is_even(&self) -> bool { (*self) & 1 == 0 }
-
-            /// Returns `true` if the number is not divisible by `2`
-            #[inline]
-            fn is_odd(&self) -> bool { !self.is_even() }
-
-            /// Simultaneous truncated integer division and modulus.
-            #[inline]
-            fn div_rem(&self, other: &Self) -> (Self, Self) {
-                (*self / *other, *self % *other)
-            }
-        }
-
-        #[cfg(test)]
-        mod $test_mod {
-            use Integer;
-
-            /// Checks that the division rule holds for:
-            ///
-            /// - `n`: numerator (dividend)
-            /// - `d`: denominator (divisor)
-            /// - `qr`: quotient and remainder
-            #[cfg(test)]
-            fn test_division_rule((n,d): ($T, $T), (q,r): ($T, $T)) {
-                assert_eq!(d * q + r, n);
-            }
-
-            #[test]
-            fn test_div_rem() {
-                fn test_nd_dr(nd: ($T,$T), qr: ($T,$T)) {
-                    let (n,d) = nd;
-                    let separate_div_rem = (n / d, n % d);
-                    let combined_div_rem = n.div_rem(&d);
-
-                    assert_eq!(separate_div_rem, qr);
-                    assert_eq!(combined_div_rem, qr);
-
-                    test_division_rule(nd, separate_div_rem);
-                    test_division_rule(nd, combined_div_rem);
-                }
-
-                test_nd_dr(( 8,  3), ( 2,  2));
-                test_nd_dr(( 8, -3), (-2,  2));
-                test_nd_dr((-8,  3), (-2, -2));
-                test_nd_dr((-8, -3), ( 2, -2));
-
-                test_nd_dr(( 1,  2), ( 0,  1));
-                test_nd_dr(( 1, -2), ( 0,  1));
-                test_nd_dr((-1,  2), ( 0, -1));
-                test_nd_dr((-1, -2), ( 0, -1));
-            }
-
-            #[test]
-            fn test_div_mod_floor() {
-                fn test_nd_dm(nd: ($T,$T), dm: ($T,$T)) {
-                    let (n,d) = nd;
-                    let separate_div_mod_floor = (n.div_floor(&d), n.mod_floor(&d));
-                    let combined_div_mod_floor = n.div_mod_floor(&d);
-
-                    assert_eq!(separate_div_mod_floor, dm);
-                    assert_eq!(combined_div_mod_floor, dm);
-
-                    test_division_rule(nd, separate_div_mod_floor);
-                    test_division_rule(nd, combined_div_mod_floor);
-                }
-
-                test_nd_dm(( 8,  3), ( 2,  2));
-                test_nd_dm(( 8, -3), (-3, -1));
-                test_nd_dm((-8,  3), (-3,  1));
-                test_nd_dm((-8, -3), ( 2, -2));
-
-                test_nd_dm(( 1,  2), ( 0,  1));
-                test_nd_dm(( 1, -2), (-1, -1));
-                test_nd_dm((-1,  2), (-1,  1));
-                test_nd_dm((-1, -2), ( 0, -1));
-            }
-
-            #[test]
-            fn test_gcd() {
-                assert_eq!((10 as $T).gcd(&2), 2 as $T);
-                assert_eq!((10 as $T).gcd(&3), 1 as $T);
-                assert_eq!((0 as $T).gcd(&3), 3 as $T);
-                assert_eq!((3 as $T).gcd(&3), 3 as $T);
-                assert_eq!((56 as $T).gcd(&42), 14 as $T);
-                assert_eq!((3 as $T).gcd(&-3), 3 as $T);
-                assert_eq!((-6 as $T).gcd(&3), 3 as $T);
-                assert_eq!((-4 as $T).gcd(&-2), 2 as $T);
-            }
-
-            #[test]
-            fn test_gcd_cmp_with_euclidean() {
-                fn euclidean_gcd(mut m: $T, mut n: $T) -> $T {
-                    while m != 0 {
-                        ::std::mem::swap(&mut m, &mut n);
-                        m %= n;
-                    }
-
-                    n.abs()
-                }
-
-                // gcd(-128, b) = 128 is not representable as positive value
-                // for i8
-                for i in -127..127 {
-                    for j in -127..127 {
-                        assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
-                    }
-                }
-
-                // last value
-                // FIXME: Use inclusive ranges for above loop when implemented
-                let i = 127;
-                for j in -127..127 {
-                    assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
-                }
-                assert_eq!(127.gcd(&127), 127);
-            }
-
-            #[test]
-            fn test_gcd_min_val() {
-                let min = <$T>::min_value();
-                let max = <$T>::max_value();
-                let max_pow2 = max / 2 + 1;
-                assert_eq!(min.gcd(&max), 1 as $T);
-                assert_eq!(max.gcd(&min), 1 as $T);
-                assert_eq!(min.gcd(&max_pow2), max_pow2);
-                assert_eq!(max_pow2.gcd(&min), max_pow2);
-                assert_eq!(min.gcd(&42), 2 as $T);
-                assert_eq!((42 as $T).gcd(&min), 2 as $T);
-            }
-
-            #[test]
-            #[should_panic]
-            fn test_gcd_min_val_min_val() {
-                let min = <$T>::min_value();
-                assert!(min.gcd(&min) >= 0);
-            }
-
-            #[test]
-            #[should_panic]
-            fn test_gcd_min_val_0() {
-                let min = <$T>::min_value();
-                assert!(min.gcd(&0) >= 0);
-            }
-
-            #[test]
-            #[should_panic]
-            fn test_gcd_0_min_val() {
-                let min = <$T>::min_value();
-                assert!((0 as $T).gcd(&min) >= 0);
-            }
-
-            #[test]
-            fn test_lcm() {
-                assert_eq!((1 as $T).lcm(&0), 0 as $T);
-                assert_eq!((0 as $T).lcm(&1), 0 as $T);
-                assert_eq!((1 as $T).lcm(&1), 1 as $T);
-                assert_eq!((-1 as $T).lcm(&1), 1 as $T);
-                assert_eq!((1 as $T).lcm(&-1), 1 as $T);
-                assert_eq!((-1 as $T).lcm(&-1), 1 as $T);
-                assert_eq!((8 as $T).lcm(&9), 72 as $T);
-                assert_eq!((11 as $T).lcm(&5), 55 as $T);
-            }
-
-            #[test]
-            fn test_even() {
-                assert_eq!((-4 as $T).is_even(), true);
-                assert_eq!((-3 as $T).is_even(), false);
-                assert_eq!((-2 as $T).is_even(), true);
-                assert_eq!((-1 as $T).is_even(), false);
-                assert_eq!((0 as $T).is_even(), true);
-                assert_eq!((1 as $T).is_even(), false);
-                assert_eq!((2 as $T).is_even(), true);
-                assert_eq!((3 as $T).is_even(), false);
-                assert_eq!((4 as $T).is_even(), true);
-            }
-
-            #[test]
-            fn test_odd() {
-                assert_eq!((-4 as $T).is_odd(), false);
-                assert_eq!((-3 as $T).is_odd(), true);
-                assert_eq!((-2 as $T).is_odd(), false);
-                assert_eq!((-1 as $T).is_odd(), true);
-                assert_eq!((0 as $T).is_odd(), false);
-                assert_eq!((1 as $T).is_odd(), true);
-                assert_eq!((2 as $T).is_odd(), false);
-                assert_eq!((3 as $T).is_odd(), true);
-                assert_eq!((4 as $T).is_odd(), false);
-            }
-        }
-    )
-}
-
-impl_integer_for_isize!(i8, test_integer_i8);
-impl_integer_for_isize!(i16, test_integer_i16);
-impl_integer_for_isize!(i32, test_integer_i32);
-impl_integer_for_isize!(i64, test_integer_i64);
-impl_integer_for_isize!(isize, test_integer_isize);
-
-macro_rules! impl_integer_for_usize {
-    ($T:ty, $test_mod:ident) => (
-        impl Integer for $T {
-            /// Unsigned integer division. Returns the same result as `div` (`/`).
-            #[inline]
-            fn div_floor(&self, other: &Self) -> Self {
-                *self / *other
-            }
-
-            /// Unsigned integer modulo operation. Returns the same result as `rem` (`%`).
-            #[inline]
-            fn mod_floor(&self, other: &Self) -> Self {
-                *self % *other
-            }
-
-            /// Calculates the Greatest Common Divisor (GCD) of the number and `other`
-            #[inline]
-            fn gcd(&self, other: &Self) -> Self {
-                // Use Stein's algorithm
-                let mut m = *self;
-                let mut n = *other;
-                if m == 0 || n == 0 { return m | n }
-
-                // find common factors of 2
-                let shift = (m | n).trailing_zeros();
-
-                // divide n and m by 2 until odd
-                // m inside loop
-                n >>= n.trailing_zeros();
-
-                while m != 0 {
-                    m >>= m.trailing_zeros();
-                    if n > m { ::std::mem::swap(&mut n, &mut m) }
-                    m -= n;
-                }
-
-                n << shift
-            }
-
-            /// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
-            #[inline]
-            fn lcm(&self, other: &Self) -> Self {
-                *self * (*other / self.gcd(other))
-            }
-
-            /// Deprecated, use `is_multiple_of` instead.
-            #[inline]
-            fn divides(&self, other: &Self) -> bool {
-                self.is_multiple_of(other)
-            }
-
-            /// Returns `true` if the number is a multiple of `other`.
-            #[inline]
-            fn is_multiple_of(&self, other: &Self) -> bool {
-                *self % *other == 0
-            }
-
-            /// Returns `true` if the number is divisible by `2`.
-            #[inline]
-            fn is_even(&self) -> bool {
-                *self % 2 == 0
-            }
-
-            /// Returns `true` if the number is not divisible by `2`.
-            #[inline]
-            fn is_odd(&self) -> bool {
-                !self.is_even()
-            }
-
-            /// Simultaneous truncated integer division and modulus.
-            #[inline]
-            fn div_rem(&self, other: &Self) -> (Self, Self) {
-                (*self / *other, *self % *other)
-            }
-        }
-
-        #[cfg(test)]
-        mod $test_mod {
-            use Integer;
-
-            #[test]
-            fn test_div_mod_floor() {
-                assert_eq!((10 as $T).div_floor(&(3 as $T)), 3 as $T);
-                assert_eq!((10 as $T).mod_floor(&(3 as $T)), 1 as $T);
-                assert_eq!((10 as $T).div_mod_floor(&(3 as $T)), (3 as $T, 1 as $T));
-                assert_eq!((5 as $T).div_floor(&(5 as $T)), 1 as $T);
-                assert_eq!((5 as $T).mod_floor(&(5 as $T)), 0 as $T);
-                assert_eq!((5 as $T).div_mod_floor(&(5 as $T)), (1 as $T, 0 as $T));
-                assert_eq!((3 as $T).div_floor(&(7 as $T)), 0 as $T);
-                assert_eq!((3 as $T).mod_floor(&(7 as $T)), 3 as $T);
-                assert_eq!((3 as $T).div_mod_floor(&(7 as $T)), (0 as $T, 3 as $T));
-            }
-
-            #[test]
-            fn test_gcd() {
-                assert_eq!((10 as $T).gcd(&2), 2 as $T);
-                assert_eq!((10 as $T).gcd(&3), 1 as $T);
-                assert_eq!((0 as $T).gcd(&3), 3 as $T);
-                assert_eq!((3 as $T).gcd(&3), 3 as $T);
-                assert_eq!((56 as $T).gcd(&42), 14 as $T);
-            }
-
-            #[test]
-            fn test_gcd_cmp_with_euclidean() {
-                fn euclidean_gcd(mut m: $T, mut n: $T) -> $T {
-                    while m != 0 {
-                        ::std::mem::swap(&mut m, &mut n);
-                        m %= n;
-                    }
-                    n
-                }
-
-                for i in 0..255 {
-                    for j in 0..255 {
-                        assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
-                    }
-                }
-
-                // last value
-                // FIXME: Use inclusive ranges for above loop when implemented
-                let i = 255;
-                for j in 0..255 {
-                    assert_eq!(euclidean_gcd(i,j), i.gcd(&j));
-                }
-                assert_eq!(255.gcd(&255), 255);
-            }
-
-            #[test]
-            fn test_lcm() {
-                assert_eq!((1 as $T).lcm(&0), 0 as $T);
-                assert_eq!((0 as $T).lcm(&1), 0 as $T);
-                assert_eq!((1 as $T).lcm(&1), 1 as $T);
-                assert_eq!((8 as $T).lcm(&9), 72 as $T);
-                assert_eq!((11 as $T).lcm(&5), 55 as $T);
-                assert_eq!((15 as $T).lcm(&17), 255 as $T);
-            }
-
-            #[test]
-            fn test_is_multiple_of() {
-                assert!((6 as $T).is_multiple_of(&(6 as $T)));
-                assert!((6 as $T).is_multiple_of(&(3 as $T)));
-                assert!((6 as $T).is_multiple_of(&(1 as $T)));
-            }
-
-            #[test]
-            fn test_even() {
-                assert_eq!((0 as $T).is_even(), true);
-                assert_eq!((1 as $T).is_even(), false);
-                assert_eq!((2 as $T).is_even(), true);
-                assert_eq!((3 as $T).is_even(), false);
-                assert_eq!((4 as $T).is_even(), true);
-            }
-
-            #[test]
-            fn test_odd() {
-                assert_eq!((0 as $T).is_odd(), false);
-                assert_eq!((1 as $T).is_odd(), true);
-                assert_eq!((2 as $T).is_odd(), false);
-                assert_eq!((3 as $T).is_odd(), true);
-                assert_eq!((4 as $T).is_odd(), false);
-            }
-        }
-    )
-}
-
-impl_integer_for_usize!(u8, test_integer_u8);
-impl_integer_for_usize!(u16, test_integer_u16);
-impl_integer_for_usize!(u32, test_integer_u32);
-impl_integer_for_usize!(u64, test_integer_u64);
-impl_integer_for_usize!(usize, test_integer_usize);
-
-#[test]
-fn test_lcm_overflow() {
-    macro_rules! check {
-        ($t:ty, $x:expr, $y:expr, $r:expr) => { {
-            let x: $t = $x;
-            let y: $t = $y;
-            let o = x.checked_mul(y);
-            assert!(o.is_none(),
-                    "sanity checking that {} input {} * {} overflows",
-                    stringify!($t), x, y);
-            assert_eq!(x.lcm(&y), $r);
-            assert_eq!(y.lcm(&x), $r);
-        } }
-    }
-
-    // Original bug (Issue #166)
-    check!(i64, 46656000000000000, 600, 46656000000000000);
-
-    check!(i8, 0x40, 0x04, 0x40);
-    check!(u8, 0x80, 0x02, 0x80);
-    check!(i16, 0x40_00, 0x04, 0x40_00);
-    check!(u16, 0x80_00, 0x02, 0x80_00);
-    check!(i32, 0x4000_0000, 0x04, 0x4000_0000);
-    check!(u32, 0x8000_0000, 0x02, 0x8000_0000);
-    check!(i64, 0x4000_0000_0000_0000, 0x04, 0x4000_0000_0000_0000);
-    check!(u64, 0x8000_0000_0000_0000, 0x02, 0x8000_0000_0000_0000);
-}

iter/Cargo.toml

@@ -1,22 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-description = "External iterators for generic mathematics"
-documentation = "http://rust-num.github.io/num"
-homepage = "https://github.com/rust-num/num"
-keywords = ["mathematics", "numerics"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/rust-num/num"
-name = "num-iter"
-version = "0.1.32"
-
-[dependencies]
-
-[dependencies.num-integer]
-optional = false
-path = "../integer"
-version = "0.1.32"
-
-[dependencies.num-traits]
-optional = false
-path = "../traits"
-version = "0.1.32"

iter/src/lib.rs

@@ -1,374 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! External iterators for generic mathematics
-
-extern crate num_traits as traits;
-extern crate num_integer as integer;
-
-use integer::Integer;
-use traits::{Zero, One, CheckedAdd, ToPrimitive};
-use std::ops::{Add, Sub};
-
-/// An iterator over the range [start, stop)
-#[derive(Clone)]
-pub struct Range<A> {
-    state: A,
-    stop: A,
-    one: A
-}
-
-/// Returns an iterator over the given range [start, stop) (that is, starting
-/// at start (inclusive), and ending at stop (exclusive)).
-///
-/// # Example
-///
-/// ```rust
-/// let array = [0, 1, 2, 3, 4];
-///
-/// for i in num_iter::range(0, 5) {
-///     println!("{}", i);
-///     assert_eq!(i,  array[i]);
-/// }
-/// ```
-#[inline]
-pub fn range<A>(start: A, stop: A) -> Range<A>
-    where A: Add<A, Output = A> + PartialOrd + Clone + One
-{
-    Range{state: start, stop: stop, one: One::one()}
-}
-
-// FIXME: rust-lang/rust#10414: Unfortunate type bound
-impl<A> Iterator for Range<A>
-    where A: Add<A, Output = A> + PartialOrd + Clone + ToPrimitive
-{
-    type Item = A;
-
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        if self.state < self.stop {
-            let result = self.state.clone();
-            self.state = self.state.clone() + self.one.clone();
-            Some(result)
-        } else {
-            None
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        // This first checks if the elements are representable as i64. If they aren't, try u64 (to
-        // handle cases like range(huge, huger)). We don't use usize/int because the difference of
-        // the i64/u64 might lie within their range.
-        let bound = match self.state.to_i64() {
-            Some(a) => {
-                let sz = self.stop.to_i64().map(|b| b.checked_sub(a));
-                match sz {
-                    Some(Some(bound)) => bound.to_usize(),
-                    _ => None,
-                }
-            },
-            None => match self.state.to_u64() {
-                Some(a) => {
-                    let sz = self.stop.to_u64().map(|b| b.checked_sub(a));
-                    match sz {
-                        Some(Some(bound)) => bound.to_usize(),
-                        _ => None
-                    }
-                },
-                None => None
-            }
-        };
-
-        match bound {
-            Some(b) => (b, Some(b)),
-            // Standard fallback for unbounded/unrepresentable bounds
-            None => (0, None)
-        }
-    }
-}
-
-/// `Integer` is required to ensure the range will be the same regardless of
-/// the direction it is consumed.
-impl<A> DoubleEndedIterator for Range<A>
-    where A: Integer + Clone + ToPrimitive
-{
-    #[inline]
-    fn next_back(&mut self) -> Option<A> {
-        if self.stop > self.state {
-            self.stop = self.stop.clone() - self.one.clone();
-            Some(self.stop.clone())
-        } else {
-            None
-        }
-    }
-}
-
-/// An iterator over the range [start, stop]
-#[derive(Clone)]
-pub struct RangeInclusive<A> {
-    range: Range<A>,
-    done: bool,
-}
-
-/// Return an iterator over the range [start, stop]
-#[inline]
-pub fn range_inclusive<A>(start: A, stop: A) -> RangeInclusive<A>
-    where A: Add<A, Output = A> + PartialOrd + Clone + One
-{
-    RangeInclusive{range: range(start, stop), done: false}
-}
-
-impl<A> Iterator for RangeInclusive<A>
-    where A: Add<A, Output = A> + PartialOrd + Clone + ToPrimitive
-{
-    type Item = A;
-
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        match self.range.next() {
-            Some(x) => Some(x),
-            None => {
-                if !self.done && self.range.state == self.range.stop {
-                    self.done = true;
-                    Some(self.range.stop.clone())
-                } else {
-                    None
-                }
-            }
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let (lo, hi) = self.range.size_hint();
-        if self.done {
-            (lo, hi)
-        } else {
-            let lo = lo.saturating_add(1);
-            let hi = match hi {
-                Some(x) => x.checked_add(1),
-                None => None
-            };
-            (lo, hi)
-        }
-    }
-}
-
-impl<A> DoubleEndedIterator for RangeInclusive<A>
-    where A: Sub<A, Output = A> + Integer + Clone + ToPrimitive
-{
-    #[inline]
-    fn next_back(&mut self) -> Option<A> {
-        if self.range.stop > self.range.state {
-            let result = self.range.stop.clone();
-            self.range.stop = self.range.stop.clone() - self.range.one.clone();
-            Some(result)
-        } else if !self.done && self.range.state == self.range.stop {
-            self.done = true;
-            Some(self.range.stop.clone())
-        } else {
-            None
-        }
-    }
-}
-
-/// An iterator over the range [start, stop) by `step`. It handles overflow by stopping.
-#[derive(Clone)]
-pub struct RangeStep<A> {
-    state: A,
-    stop: A,
-    step: A,
-    rev: bool,
-}
-
-/// Return an iterator over the range [start, stop) by `step`. It handles overflow by stopping.
-#[inline]
-pub fn range_step<A>(start: A, stop: A, step: A) -> RangeStep<A>
-    where A: CheckedAdd + PartialOrd + Clone + Zero
-{
-    let rev = step < Zero::zero();
-    RangeStep{state: start, stop: stop, step: step, rev: rev}
-}
-
-impl<A> Iterator for RangeStep<A>
-    where A: CheckedAdd + PartialOrd + Clone
-{
-    type Item = A;
-
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        if (self.rev && self.state > self.stop) || (!self.rev && self.state < self.stop) {
-            let result = self.state.clone();
-            match self.state.checked_add(&self.step) {
-                Some(x) => self.state = x,
-                None => self.state = self.stop.clone()
-            }
-            Some(result)
-        } else {
-            None
-        }
-    }
-}
-
-/// An iterator over the range [start, stop] by `step`. It handles overflow by stopping.
-#[derive(Clone)]
-pub struct RangeStepInclusive<A> {
-    state: A,
-    stop: A,
-    step: A,
-    rev: bool,
-    done: bool,
-}
-
-/// Return an iterator over the range [start, stop] by `step`. It handles overflow by stopping.
-#[inline]
-pub fn range_step_inclusive<A>(start: A, stop: A, step: A) -> RangeStepInclusive<A>
-    where A: CheckedAdd + PartialOrd + Clone + Zero
-{
-    let rev = step < Zero::zero();
-    RangeStepInclusive{state: start, stop: stop, step: step, rev: rev, done: false}
-}
-
-impl<A> Iterator for RangeStepInclusive<A>
-    where A: CheckedAdd + PartialOrd + Clone + PartialEq
-{
-    type Item = A;
-
-    #[inline]
-    fn next(&mut self) -> Option<A> {
-        if !self.done && ((self.rev && self.state >= self.stop) ||
-                          (!self.rev && self.state <= self.stop)) {
-            let result = self.state.clone();
-            match self.state.checked_add(&self.step) {
-                Some(x) => self.state = x,
-                None => self.done = true
-            }
-            Some(result)
-        } else {
-            None
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::usize;
-    use std::ops::{Add, Mul};
-    use std::cmp::Ordering;
-    use traits::{One, ToPrimitive};
-
-    #[test]
-    fn test_range() {
-        /// A mock type to check Range when ToPrimitive returns None
-        struct Foo;
-
-        impl ToPrimitive for Foo {
-            fn to_i64(&self) -> Option<i64> { None }
-            fn to_u64(&self) -> Option<u64> { None }
-        }
-
-        impl Add<Foo> for Foo {
-            type Output = Foo;
-
-            fn add(self, _: Foo) -> Foo {
-                Foo
-            }
-        }
-
-        impl PartialEq for Foo {
-            fn eq(&self, _: &Foo) -> bool {
-                true
-            }
-        }
-
-        impl PartialOrd for Foo {
-            fn partial_cmp(&self, _: &Foo) -> Option<Ordering> {
-                None
-            }
-        }
-
-        impl Clone for Foo {
-            fn clone(&self) -> Foo {
-                Foo
-            }
-        }
-
-        impl Mul<Foo> for Foo {
-            type Output = Foo;
-
-            fn mul(self, _: Foo) -> Foo {
-                Foo
-            }
-        }
-
-        impl One for Foo {
-            fn one() -> Foo {
-                Foo
-            }
-        }
-
-        assert!(super::range(0, 5).collect::<Vec<isize>>() == vec![0, 1, 2, 3, 4]);
-        assert!(super::range(-10, -1).collect::<Vec<isize>>() ==
-                vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
-        assert!(super::range(0, 5).rev().collect::<Vec<isize>>() == vec![4, 3, 2, 1, 0]);
-        assert_eq!(super::range(200, -5).count(), 0);
-        assert_eq!(super::range(200, -5).rev().count(), 0);
-        assert_eq!(super::range(200, 200).count(), 0);
-        assert_eq!(super::range(200, 200).rev().count(), 0);
-
-        assert_eq!(super::range(0, 100).size_hint(), (100, Some(100)));
-        // this test is only meaningful when sizeof usize < sizeof u64
-        assert_eq!(super::range(usize::MAX - 1, usize::MAX).size_hint(), (1, Some(1)));
-        assert_eq!(super::range(-10, -1).size_hint(), (9, Some(9)));
-    }
-
-    #[test]
-    fn test_range_inclusive() {
-        assert!(super::range_inclusive(0, 5).collect::<Vec<isize>>() ==
-                vec![0, 1, 2, 3, 4, 5]);
-        assert!(super::range_inclusive(0, 5).rev().collect::<Vec<isize>>() ==
-                vec![5, 4, 3, 2, 1, 0]);
-        assert_eq!(super::range_inclusive(200, -5).count(), 0);
-        assert_eq!(super::range_inclusive(200, -5).rev().count(), 0);
-        assert!(super::range_inclusive(200, 200).collect::<Vec<isize>>() == vec![200]);
-        assert!(super::range_inclusive(200, 200).rev().collect::<Vec<isize>>() == vec![200]);
-    }
-
-    #[test]
-    fn test_range_step() {
-        assert!(super::range_step(0, 20, 5).collect::<Vec<isize>>() ==
-                vec![0, 5, 10, 15]);
-        assert!(super::range_step(20, 0, -5).collect::<Vec<isize>>() ==
-                vec![20, 15, 10, 5]);
-        assert!(super::range_step(20, 0, -6).collect::<Vec<isize>>() ==
-                vec![20, 14, 8, 2]);
-        assert!(super::range_step(200u8, 255, 50).collect::<Vec<u8>>() ==
-                vec![200u8, 250]);
-        assert!(super::range_step(200, -5, 1).collect::<Vec<isize>>() == vec![]);
-        assert!(super::range_step(200, 200, 1).collect::<Vec<isize>>() == vec![]);
-    }
-
-    #[test]
-    fn test_range_step_inclusive() {
-        assert!(super::range_step_inclusive(0, 20, 5).collect::<Vec<isize>>() ==
-                vec![0, 5, 10, 15, 20]);
-        assert!(super::range_step_inclusive(20, 0, -5).collect::<Vec<isize>>() ==
-                vec![20, 15, 10, 5, 0]);
-        assert!(super::range_step_inclusive(20, 0, -6).collect::<Vec<isize>>() ==
-                vec![20, 14, 8, 2]);
-        assert!(super::range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() ==
-                vec![200u8, 250]);
-        assert!(super::range_step_inclusive(200, -5, 1).collect::<Vec<isize>>() ==
-                vec![]);
-        assert!(super::range_step_inclusive(200, 200, 1).collect::<Vec<isize>>() ==
-                vec![200]);
-    }
-}

macros/Cargo.toml

@@ -1,17 +0,0 @@
-[package]
-name = "num-macros"
-version = "0.1.33"
-authors = ["The Rust Project Developers"]
-license = "MIT/Apache-2.0"
-homepage = "https://github.com/rust-num/num"
-repository = "https://github.com/rust-num/num"
-documentation = "http://rust-num.github.io/num"
-keywords = ["mathematics", "numerics"]
-description = "Numeric syntax extensions"
-
-[lib]
-name = "num_macros"
-plugin = true
-
-[dev-dependencies]
-num = { path = "..", version = "0.1" }

macros/src/lib.rs

@@ -1,200 +0,0 @@
-// Copyright 2012-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(plugin_registrar, rustc_private)]
-
-extern crate syntax;
-extern crate syntax_ext;
-extern crate rustc_plugin;
-
-use syntax::ast::{MetaItem, Expr, BinOpKind};
-use syntax::ast;
-use syntax::codemap::Span;
-use syntax::ext::base::{ExtCtxt, Annotatable};
-use syntax::ext::build::AstBuilder;
-use syntax_ext::deriving::generic::*;
-use syntax_ext::deriving::generic::ty::*;
-use syntax::parse::token::InternedString;
-use syntax::ptr::P;
-use syntax::ext::base::MultiDecorator;
-use syntax::parse::token;
-
-use rustc_plugin::Registry;
-
-macro_rules! pathvec {
-    ($($x:ident)::+) => (
-        vec![ $( stringify!($x) ),+ ]
-    )
-}
-
-macro_rules! path {
-    ($($x:tt)*) => (
-        ::syntax_ext::deriving::generic::ty::Path::new( pathvec!( $($x)* ) )
-    )
-}
-
-macro_rules! path_local {
-    ($x:ident) => (
-        ::syntax_ext::deriving::generic::ty::Path::new_local(stringify!($x))
-    )
-}
-
-macro_rules! pathvec_std {
-    ($cx:expr, $first:ident :: $($rest:ident)::+) => ({
-        let mut v = pathvec!($($rest)::+);
-        if let Some(s) = $cx.crate_root {
-            v.insert(0, s);
-        }
-        v
-    })
-}
-
-pub fn expand_deriving_from_primitive(cx: &mut ExtCtxt,
-                                      span: Span,
-                                      mitem: &MetaItem,
-                                      item: &Annotatable,
-                                      push: &mut FnMut(Annotatable))
-{
-    let inline = cx.meta_word(span, InternedString::new("inline"));
-    let attrs = vec!(cx.attribute(span, inline));
-    let trait_def = TraitDef {
-        is_unsafe: false,
-        span: span,
-        attributes: Vec::new(),
-        path: path!(num::FromPrimitive),
-        additional_bounds: Vec::new(),
-        generics: LifetimeBounds::empty(),
-        methods: vec!(
-            MethodDef {
-                name: "from_i64",
-                is_unsafe: false,
-                unify_fieldless_variants: false,
-                generics: LifetimeBounds::empty(),
-                explicit_self: None,
-                args: vec!(Literal(path_local!(i64))),
-                ret_ty: Literal(Path::new_(pathvec_std!(cx, core::option::Option),
-                                           None,
-                                           vec!(Box::new(Self_)),
-                                           true)),
-                // #[inline] liable to cause code-bloat
-                attributes: attrs.clone(),
-                combine_substructure: combine_substructure(Box::new(|c, s, sub| {
-                    cs_from("i64", c, s, sub)
-                })),
-            },
-            MethodDef {
-                name: "from_u64",
-                is_unsafe: false,
-                unify_fieldless_variants: false,
-                generics: LifetimeBounds::empty(),
-                explicit_self: None,
-                args: vec!(Literal(path_local!(u64))),
-                ret_ty: Literal(Path::new_(pathvec_std!(cx, core::option::Option),
-                                           None,
-                                           vec!(Box::new(Self_)),
-                                           true)),
-                // #[inline] liable to cause code-bloat
-                attributes: attrs,
-                combine_substructure: combine_substructure(Box::new(|c, s, sub| {
-                    cs_from("u64", c, s, sub)
-                })),
-            }
-        ),
-        associated_types: Vec::new(),
-    };
-
-    trait_def.expand(cx, mitem, &item, push)
-}
-
-fn cs_from(name: &str, cx: &mut ExtCtxt, trait_span: Span, substr: &Substructure) -> P<Expr> {
-    if substr.nonself_args.len() != 1 {
-        cx.span_bug(trait_span, "incorrect number of arguments in `derive(FromPrimitive)`")
-    }
-
-    let n = &substr.nonself_args[0];
-
-    match *substr.fields {
-        StaticStruct(..) => {
-            cx.span_err(trait_span, "`FromPrimitive` cannot be derived for structs");
-            return cx.expr_fail(trait_span, InternedString::new(""));
-        }
-        StaticEnum(enum_def, _) => {
-            if enum_def.variants.is_empty() {
-                cx.span_err(trait_span,
-                            "`FromPrimitive` cannot be derived for enums with no variants");
-                return cx.expr_fail(trait_span, InternedString::new(""));
-            }
-
-            let mut arms = Vec::new();
-
-            for variant in &enum_def.variants {
-                match variant.node.data {
-                    ast::VariantData::Unit(..) => {
-                        let span = variant.span;
-
-                        // expr for `$n == $variant as $name`
-                        let path = cx.path(span, vec![substr.type_ident, variant.node.name]);
-                        let variant = cx.expr_path(path);
-                        let ty = cx.ty_ident(span, cx.ident_of(name));
-                        let cast = cx.expr_cast(span, variant.clone(), ty);
-                        let guard = cx.expr_binary(span, BinOpKind::Eq, n.clone(), cast);
-
-                        // expr for `Some($variant)`
-                        let body = cx.expr_some(span, variant);
-
-                        // arm for `_ if $guard => $body`
-                        let arm = ast::Arm {
-                            attrs: vec!(),
-                            pats: vec!(cx.pat_wild(span)),
-                            guard: Some(guard),
-                            body: body,
-                        };
-
-                        arms.push(arm);
-                    }
-                    ast::VariantData::Tuple(..) => {
-                        cx.span_err(trait_span,
-                                    "`FromPrimitive` cannot be derived for \
-                                    enum variants with arguments");
-                        return cx.expr_fail(trait_span,
-                                            InternedString::new(""));
-                    }
-                    ast::VariantData::Struct(..) => {
-                        cx.span_err(trait_span,
-                                    "`FromPrimitive` cannot be derived for enums \
-                                    with struct variants");
-                        return cx.expr_fail(trait_span,
-                                            InternedString::new(""));
-                    }
-                }
-            }
-
-            // arm for `_ => None`
-            let arm = ast::Arm {
-                attrs: vec!(),
-                pats: vec!(cx.pat_wild(trait_span)),
-                guard: None,
-                body: cx.expr_none(trait_span),
-            };
-            arms.push(arm);
-
-            cx.expr_match(trait_span, n.clone(), arms)
-        }
-        _ => cx.span_bug(trait_span, "expected StaticEnum in derive(FromPrimitive)")
-    }
-}
-
-#[plugin_registrar]
-#[doc(hidden)]
-pub fn plugin_registrar(reg: &mut Registry) {
-    reg.register_syntax_extension(
-        token::intern("derive_NumFromPrimitive"),
-        MultiDecorator(Box::new(expand_deriving_from_primitive)));
-}

macros/tests/test_macro.rs

@@ -1,36 +0,0 @@
-// Copyright 2013-2015 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(custom_derive, plugin)]
-#![plugin(num_macros)]
-
-extern crate num;
-
-#[derive(Debug, PartialEq, NumFromPrimitive)]
-enum Color {
-    Red,
-    Blue,
-    Green,
-}
-
-#[test]
-fn test_from_primitive() {
-    let v: Vec<Option<Color>> = vec![
-        num::FromPrimitive::from_u64(0),
-        num::FromPrimitive::from_u64(1),
-        num::FromPrimitive::from_u64(2),
-        num::FromPrimitive::from_u64(3),
-    ];
-
-    assert_eq!(
-        v,
-        vec![Some(Color::Red), Some(Color::Blue), Some(Color::Green), None]
-    );
-}

rational/Cargo.toml

@@ -1,37 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-description = "Rational numbers implementation for Rust"
-documentation = "http://rust-num.github.io/num"
-homepage = "https://github.com/rust-num/num"
-keywords = ["mathematics", "numerics"]
-license = "MIT/Apache-2.0"
-name = "num-rational"
-repository = "https://github.com/rust-num/num"
-version = "0.1.35"
-
-[dependencies]
-
-[dependencies.num-bigint]
-optional = true
-path = "../bigint"
-version = "0.1.32"
-
-[dependencies.num-integer]
-path = "../integer"
-version = "0.1.32"
-
-[dependencies.num-traits]
-path = "../traits"
-version = "0.1.32"
-
-[dependencies.rustc-serialize]
-optional = true
-version = "0.3.19"
-
-[dependencies.serde]
-optional = true
-version = ">= 0.7.0, < 0.9.0"
-
-[features]
-default = ["bigint", "rustc-serialize"]
-bigint = ["num-bigint"]

src/bounds.rs

@@ -0,0 +1,127 @@
+use core::num::Wrapping;
+use core::{f32, f64};
+#[cfg(has_i128)]
+use core::{i128, u128};
+use core::{i16, i32, i64, i8, isize};
+use core::{u16, u32, u64, u8, usize};
+
+/// Numbers which have upper and lower bounds
+pub trait Bounded {
+    // FIXME (#5527): These should be associated constants
+    /// returns the smallest finite number this type can represent
+    fn min_value() -> Self;
+    /// returns the largest finite number this type can represent
+    fn max_value() -> Self;
+}
+
+macro_rules! bounded_impl {
+    ($t:ty, $min:expr, $max:expr) => {
+        impl Bounded for $t {
+            #[inline]
+            fn min_value() -> $t {
+                $min
+            }
+
+            #[inline]
+            fn max_value() -> $t {
+                $max
+            }
+        }
+    };
+}
+
+bounded_impl!(usize, usize::MIN, usize::MAX);
+bounded_impl!(u8, u8::MIN, u8::MAX);
+bounded_impl!(u16, u16::MIN, u16::MAX);
+bounded_impl!(u32, u32::MIN, u32::MAX);
+bounded_impl!(u64, u64::MIN, u64::MAX);
+#[cfg(has_i128)]
+bounded_impl!(u128, u128::MIN, u128::MAX);
+
+bounded_impl!(isize, isize::MIN, isize::MAX);
+bounded_impl!(i8, i8::MIN, i8::MAX);
+bounded_impl!(i16, i16::MIN, i16::MAX);
+bounded_impl!(i32, i32::MIN, i32::MAX);
+bounded_impl!(i64, i64::MIN, i64::MAX);
+#[cfg(has_i128)]
+bounded_impl!(i128, i128::MIN, i128::MAX);
+
+impl<T: Bounded> Bounded for Wrapping<T> {
+    fn min_value() -> Self {
+        Wrapping(T::min_value())
+    }
+    fn max_value() -> Self {
+        Wrapping(T::max_value())
+    }
+}
+
+bounded_impl!(f32, f32::MIN, f32::MAX);
+
+macro_rules! for_each_tuple_ {
+    ( $m:ident !! ) => (
+        $m! { }
+    );
+    ( $m:ident !! $h:ident, $($t:ident,)* ) => (
+        $m! { $h $($t)* }
+        for_each_tuple_! { $m !! $($t,)* }
+    );
+}
+macro_rules! for_each_tuple {
+    ($m:ident) => {
+        for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, }
+    };
+}
+
+macro_rules! bounded_tuple {
+    ( $($name:ident)* ) => (
+        impl<$($name: Bounded,)*> Bounded for ($($name,)*) {
+            #[inline]
+            fn min_value() -> Self {
+                ($($name::min_value(),)*)
+            }
+            #[inline]
+            fn max_value() -> Self {
+                ($($name::max_value(),)*)
+            }
+        }
+    );
+}
+
+for_each_tuple!(bounded_tuple);
+bounded_impl!(f64, f64::MIN, f64::MAX);
+
+#[test]
+fn wrapping_bounded() {
+    macro_rules! test_wrapping_bounded {
+        ($($t:ty)+) => {
+            $(
+                assert_eq!(<Wrapping<$t> as Bounded>::min_value().0, <$t>::min_value());
+                assert_eq!(<Wrapping<$t> as Bounded>::max_value().0, <$t>::max_value());
+            )+
+        };
+    }
+
+    test_wrapping_bounded!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[cfg(has_i128)]
+#[test]
+fn wrapping_bounded_i128() {
+    macro_rules! test_wrapping_bounded {
+        ($($t:ty)+) => {
+            $(
+                assert_eq!(<Wrapping<$t> as Bounded>::min_value().0, <$t>::min_value());
+                assert_eq!(<Wrapping<$t> as Bounded>::max_value().0, <$t>::max_value());
+            )+
+        };
+    }
+
+    test_wrapping_bounded!(u128 i128);
+}
+
+#[test]
+fn wrapping_is_bounded() {
+    fn require_bounded<T: Bounded>(_: &T) {}
+    require_bounded(&Wrapping(42_u32));
+    require_bounded(&Wrapping(-42));
+}

src/cast.rs

@@ -0,0 +1,762 @@
+use core::mem::size_of;
+use core::num::Wrapping;
+use core::{f32, f64};
+#[cfg(has_i128)]
+use core::{i128, u128};
+use core::{i16, i32, i64, i8, isize};
+use core::{u16, u32, u64, u8, usize};
+
+use float::FloatCore;
+
+/// A generic trait for converting a value to a number.
+pub trait ToPrimitive {
+    /// Converts the value of `self` to an `isize`.
+    #[inline]
+    fn to_isize(&self) -> Option<isize> {
+        self.to_i64().as_ref().and_then(ToPrimitive::to_isize)
+    }
+
+    /// Converts the value of `self` to an `i8`.
+    #[inline]
+    fn to_i8(&self) -> Option<i8> {
+        self.to_i64().as_ref().and_then(ToPrimitive::to_i8)
+    }
+
+    /// Converts the value of `self` to an `i16`.
+    #[inline]
+    fn to_i16(&self) -> Option<i16> {
+        self.to_i64().as_ref().and_then(ToPrimitive::to_i16)
+    }
+
+    /// Converts the value of `self` to an `i32`.
+    #[inline]
+    fn to_i32(&self) -> Option<i32> {
+        self.to_i64().as_ref().and_then(ToPrimitive::to_i32)
+    }
+
+    /// Converts the value of `self` to an `i64`.
+    fn to_i64(&self) -> Option<i64>;
+
+    /// Converts the value of `self` to an `i128`.
+    ///
+    /// This method is only available with feature `i128` enabled on Rust >= 1.26.
+    ///
+    /// The default implementation converts through `to_i64()`.  Types implementing
+    /// this trait should override this method if they can represent a greater range.
+    #[inline]
+    #[cfg(has_i128)]
+    fn to_i128(&self) -> Option<i128> {
+        self.to_i64().map(From::from)
+    }
+
+    /// Converts the value of `self` to a `usize`.
+    #[inline]
+    fn to_usize(&self) -> Option<usize> {
+        self.to_u64().as_ref().and_then(ToPrimitive::to_usize)
+    }
+
+    /// Converts the value of `self` to an `u8`.
+    #[inline]
+    fn to_u8(&self) -> Option<u8> {
+        self.to_u64().as_ref().and_then(ToPrimitive::to_u8)
+    }
+
+    /// Converts the value of `self` to an `u16`.
+    #[inline]
+    fn to_u16(&self) -> Option<u16> {
+        self.to_u64().as_ref().and_then(ToPrimitive::to_u16)
+    }
+
+    /// Converts the value of `self` to an `u32`.
+    #[inline]
+    fn to_u32(&self) -> Option<u32> {
+        self.to_u64().as_ref().and_then(ToPrimitive::to_u32)
+    }
+
+    /// Converts the value of `self` to an `u64`.
+    #[inline]
+    fn to_u64(&self) -> Option<u64>;
+
+    /// Converts the value of `self` to an `u128`.
+    ///
+    /// This method is only available with feature `i128` enabled on Rust >= 1.26.
+    ///
+    /// The default implementation converts through `to_u64()`.  Types implementing
+    /// this trait should override this method if they can represent a greater range.
+    #[inline]
+    #[cfg(has_i128)]
+    fn to_u128(&self) -> Option<u128> {
+        self.to_u64().map(From::from)
+    }
+
+    /// Converts the value of `self` to an `f32`.
+    #[inline]
+    fn to_f32(&self) -> Option<f32> {
+        self.to_f64().as_ref().and_then(ToPrimitive::to_f32)
+    }
+
+    /// Converts the value of `self` to an `f64`.
+    #[inline]
+    fn to_f64(&self) -> Option<f64> {
+        match self.to_i64() {
+            Some(i) => i.to_f64(),
+            None => self.to_u64().as_ref().and_then(ToPrimitive::to_f64),
+        }
+    }
+}
+
+macro_rules! impl_to_primitive_int_to_int {
+    ($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(&self) -> Option<$DstT> {
+            let min = $DstT::MIN as $SrcT;
+            let max = $DstT::MAX as $SrcT;
+            if size_of::<$SrcT>() <= size_of::<$DstT>() || (min <= *self && *self <= max) {
+                Some(*self as $DstT)
+            } else {
+                None
+            }
+        }
+    )*}
+}
+
+macro_rules! impl_to_primitive_int_to_uint {
+    ($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(&self) -> Option<$DstT> {
+            let max = $DstT::MAX as $SrcT;
+            if 0 <= *self && (size_of::<$SrcT>() <= size_of::<$DstT>() || *self <= max) {
+                Some(*self as $DstT)
+            } else {
+                None
+            }
+        }
+    )*}
+}
+
+macro_rules! impl_to_primitive_int {
+    ($T:ident) => {
+        impl ToPrimitive for $T {
+            impl_to_primitive_int_to_int! { $T:
+                fn to_isize -> isize;
+                fn to_i8 -> i8;
+                fn to_i16 -> i16;
+                fn to_i32 -> i32;
+                fn to_i64 -> i64;
+                #[cfg(has_i128)]
+                fn to_i128 -> i128;
+            }
+
+            impl_to_primitive_int_to_uint! { $T:
+                fn to_usize -> usize;
+                fn to_u8 -> u8;
+                fn to_u16 -> u16;
+                fn to_u32 -> u32;
+                fn to_u64 -> u64;
+                #[cfg(has_i128)]
+                fn to_u128 -> u128;
+            }
+
+            #[inline]
+            fn to_f32(&self) -> Option<f32> {
+                Some(*self as f32)
+            }
+            #[inline]
+            fn to_f64(&self) -> Option<f64> {
+                Some(*self as f64)
+            }
+        }
+    };
+}
+
+impl_to_primitive_int!(isize);
+impl_to_primitive_int!(i8);
+impl_to_primitive_int!(i16);
+impl_to_primitive_int!(i32);
+impl_to_primitive_int!(i64);
+#[cfg(has_i128)]
+impl_to_primitive_int!(i128);
+
+macro_rules! impl_to_primitive_uint_to_int {
+    ($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(&self) -> Option<$DstT> {
+            let max = $DstT::MAX as $SrcT;
+            if size_of::<$SrcT>() < size_of::<$DstT>() || *self <= max {
+                Some(*self as $DstT)
+            } else {
+                None
+            }
+        }
+    )*}
+}
+
+macro_rules! impl_to_primitive_uint_to_uint {
+    ($SrcT:ident : $( $(#[$cfg:meta])* fn $method:ident -> $DstT:ident ; )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(&self) -> Option<$DstT> {
+            let max = $DstT::MAX as $SrcT;
+            if size_of::<$SrcT>() <= size_of::<$DstT>() || *self <= max {
+                Some(*self as $DstT)
+            } else {
+                None
+            }
+        }
+    )*}
+}
+
+macro_rules! impl_to_primitive_uint {
+    ($T:ident) => {
+        impl ToPrimitive for $T {
+            impl_to_primitive_uint_to_int! { $T:
+                fn to_isize -> isize;
+                fn to_i8 -> i8;
+                fn to_i16 -> i16;
+                fn to_i32 -> i32;
+                fn to_i64 -> i64;
+                #[cfg(has_i128)]
+                fn to_i128 -> i128;
+            }
+
+            impl_to_primitive_uint_to_uint! { $T:
+                fn to_usize -> usize;
+                fn to_u8 -> u8;
+                fn to_u16 -> u16;
+                fn to_u32 -> u32;
+                fn to_u64 -> u64;
+                #[cfg(has_i128)]
+                fn to_u128 -> u128;
+            }
+
+            #[inline]
+            fn to_f32(&self) -> Option<f32> {
+                Some(*self as f32)
+            }
+            #[inline]
+            fn to_f64(&self) -> Option<f64> {
+                Some(*self as f64)
+            }
+        }
+    };
+}
+
+impl_to_primitive_uint!(usize);
+impl_to_primitive_uint!(u8);
+impl_to_primitive_uint!(u16);
+impl_to_primitive_uint!(u32);
+impl_to_primitive_uint!(u64);
+#[cfg(has_i128)]
+impl_to_primitive_uint!(u128);
+
+macro_rules! impl_to_primitive_float_to_float {
+    ($SrcT:ident : $( fn $method:ident -> $DstT:ident ; )*) => {$(
+        #[inline]
+        fn $method(&self) -> Option<$DstT> {
+            // Only finite values that are reducing size need to worry about overflow.
+            if size_of::<$SrcT>() > size_of::<$DstT>() && FloatCore::is_finite(*self) {
+                let n = *self as f64;
+                if n < $DstT::MIN as f64 || n > $DstT::MAX as f64 {
+                    return None;
+                }
+            }
+            // We can safely cast NaN, +-inf, and finite values in range.
+            Some(*self as $DstT)
+        }
+    )*}
+}
+
+macro_rules! impl_to_primitive_float_to_signed_int {
+    ($f:ident : $( $(#[$cfg:meta])* fn $method:ident -> $i:ident ; )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(&self) -> Option<$i> {
+            // Float as int truncates toward zero, so we want to allow values
+            // in the exclusive range `(MIN-1, MAX+1)`.
+            if size_of::<$f>() > size_of::<$i>() {
+                // With a larger size, we can represent the range exactly.
+                const MIN_M1: $f = $i::MIN as $f - 1.0;
+                const MAX_P1: $f = $i::MAX as $f + 1.0;
+                if *self > MIN_M1 && *self < MAX_P1 {
+                    return Some(*self as $i);
+                }
+            } else {
+                // We can't represent `MIN-1` exactly, but there's no fractional part
+                // at this magnitude, so we can just use a `MIN` inclusive boundary.
+                const MIN: $f = $i::MIN as $f;
+                // We can't represent `MAX` exactly, but it will round up to exactly
+                // `MAX+1` (a power of two) when we cast it.
+                const MAX_P1: $f = $i::MAX as $f;
+                if *self >= MIN && *self < MAX_P1 {
+                    return Some(*self as $i);
+                }
+            }
+            None
+        }
+    )*}
+}
+
+macro_rules! impl_to_primitive_float_to_unsigned_int {
+    ($f:ident : $( $(#[$cfg:meta])* fn $method:ident -> $u:ident ; )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(&self) -> Option<$u> {
+            // Float as int truncates toward zero, so we want to allow values
+            // in the exclusive range `(-1, MAX+1)`.
+            if size_of::<$f>() > size_of::<$u>() {
+                // With a larger size, we can represent the range exactly.
+                const MAX_P1: $f = $u::MAX as $f + 1.0;
+                if *self > -1.0 && *self < MAX_P1 {
+                    return Some(*self as $u);
+                }
+            } else {
+                // We can't represent `MAX` exactly, but it will round up to exactly
+                // `MAX+1` (a power of two) when we cast it.
+                // (`u128::MAX as f32` is infinity, but this is still ok.)
+                const MAX_P1: $f = $u::MAX as $f;
+                if *self > -1.0 && *self < MAX_P1 {
+                    return Some(*self as $u);
+                }
+            }
+            None
+        }
+    )*}
+}
+
+macro_rules! impl_to_primitive_float {
+    ($T:ident) => {
+        impl ToPrimitive for $T {
+            impl_to_primitive_float_to_signed_int! { $T:
+                fn to_isize -> isize;
+                fn to_i8 -> i8;
+                fn to_i16 -> i16;
+                fn to_i32 -> i32;
+                fn to_i64 -> i64;
+                #[cfg(has_i128)]
+                fn to_i128 -> i128;
+            }
+
+            impl_to_primitive_float_to_unsigned_int! { $T:
+                fn to_usize -> usize;
+                fn to_u8 -> u8;
+                fn to_u16 -> u16;
+                fn to_u32 -> u32;
+                fn to_u64 -> u64;
+                #[cfg(has_i128)]
+                fn to_u128 -> u128;
+            }
+
+            impl_to_primitive_float_to_float! { $T:
+                fn to_f32 -> f32;
+                fn to_f64 -> f64;
+            }
+        }
+    };
+}
+
+impl_to_primitive_float!(f32);
+impl_to_primitive_float!(f64);
+
+/// A generic trait for converting a number to a value.
+pub trait FromPrimitive: Sized {
+    /// Convert an `isize` to return an optional value of this type. If the
+    /// value cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_isize(n: isize) -> Option<Self> {
+        n.to_i64().and_then(FromPrimitive::from_i64)
+    }
+
+    /// Convert an `i8` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_i8(n: i8) -> Option<Self> {
+        FromPrimitive::from_i64(From::from(n))
+    }
+
+    /// Convert an `i16` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_i16(n: i16) -> Option<Self> {
+        FromPrimitive::from_i64(From::from(n))
+    }
+
+    /// Convert an `i32` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_i32(n: i32) -> Option<Self> {
+        FromPrimitive::from_i64(From::from(n))
+    }
+
+    /// Convert an `i64` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    fn from_i64(n: i64) -> Option<Self>;
+
+    /// Convert an `i128` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    ///
+    /// This method is only available with feature `i128` enabled on Rust >= 1.26.
+    ///
+    /// The default implementation converts through `from_i64()`.  Types implementing
+    /// this trait should override this method if they can represent a greater range.
+    #[inline]
+    #[cfg(has_i128)]
+    fn from_i128(n: i128) -> Option<Self> {
+        n.to_i64().and_then(FromPrimitive::from_i64)
+    }
+
+    /// Convert a `usize` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_usize(n: usize) -> Option<Self> {
+        n.to_u64().and_then(FromPrimitive::from_u64)
+    }
+
+    /// Convert an `u8` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_u8(n: u8) -> Option<Self> {
+        FromPrimitive::from_u64(From::from(n))
+    }
+
+    /// Convert an `u16` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_u16(n: u16) -> Option<Self> {
+        FromPrimitive::from_u64(From::from(n))
+    }
+
+    /// Convert an `u32` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_u32(n: u32) -> Option<Self> {
+        FromPrimitive::from_u64(From::from(n))
+    }
+
+    /// Convert an `u64` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    fn from_u64(n: u64) -> Option<Self>;
+
+    /// Convert an `u128` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    ///
+    /// This method is only available with feature `i128` enabled on Rust >= 1.26.
+    ///
+    /// The default implementation converts through `from_u64()`.  Types implementing
+    /// this trait should override this method if they can represent a greater range.
+    #[inline]
+    #[cfg(has_i128)]
+    fn from_u128(n: u128) -> Option<Self> {
+        n.to_u64().and_then(FromPrimitive::from_u64)
+    }
+
+    /// Convert a `f32` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_f32(n: f32) -> Option<Self> {
+        FromPrimitive::from_f64(From::from(n))
+    }
+
+    /// Convert a `f64` to return an optional value of this type. If the
+    /// type cannot be represented by this value, then `None` is returned.
+    #[inline]
+    fn from_f64(n: f64) -> Option<Self> {
+        match n.to_i64() {
+            Some(i) => FromPrimitive::from_i64(i),
+            None => n.to_u64().and_then(FromPrimitive::from_u64),
+        }
+    }
+}
+
+macro_rules! impl_from_primitive {
+    ($T:ty, $to_ty:ident) => {
+        #[allow(deprecated)]
+        impl FromPrimitive for $T {
+            #[inline]
+            fn from_isize(n: isize) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_i8(n: i8) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_i16(n: i16) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_i32(n: i32) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_i64(n: i64) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[cfg(has_i128)]
+            #[inline]
+            fn from_i128(n: i128) -> Option<$T> {
+                n.$to_ty()
+            }
+
+            #[inline]
+            fn from_usize(n: usize) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_u8(n: u8) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_u16(n: u16) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_u32(n: u32) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_u64(n: u64) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[cfg(has_i128)]
+            #[inline]
+            fn from_u128(n: u128) -> Option<$T> {
+                n.$to_ty()
+            }
+
+            #[inline]
+            fn from_f32(n: f32) -> Option<$T> {
+                n.$to_ty()
+            }
+            #[inline]
+            fn from_f64(n: f64) -> Option<$T> {
+                n.$to_ty()
+            }
+        }
+    };
+}
+
+impl_from_primitive!(isize, to_isize);
+impl_from_primitive!(i8, to_i8);
+impl_from_primitive!(i16, to_i16);
+impl_from_primitive!(i32, to_i32);
+impl_from_primitive!(i64, to_i64);
+#[cfg(has_i128)]
+impl_from_primitive!(i128, to_i128);
+impl_from_primitive!(usize, to_usize);
+impl_from_primitive!(u8, to_u8);
+impl_from_primitive!(u16, to_u16);
+impl_from_primitive!(u32, to_u32);
+impl_from_primitive!(u64, to_u64);
+#[cfg(has_i128)]
+impl_from_primitive!(u128, to_u128);
+impl_from_primitive!(f32, to_f32);
+impl_from_primitive!(f64, to_f64);
+
+macro_rules! impl_to_primitive_wrapping {
+    ($( $(#[$cfg:meta])* fn $method:ident -> $i:ident ; )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(&self) -> Option<$i> {
+            (self.0).$method()
+        }
+    )*}
+}
+
+impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
+    impl_to_primitive_wrapping! {
+        fn to_isize -> isize;
+        fn to_i8 -> i8;
+        fn to_i16 -> i16;
+        fn to_i32 -> i32;
+        fn to_i64 -> i64;
+        #[cfg(has_i128)]
+        fn to_i128 -> i128;
+
+        fn to_usize -> usize;
+        fn to_u8 -> u8;
+        fn to_u16 -> u16;
+        fn to_u32 -> u32;
+        fn to_u64 -> u64;
+        #[cfg(has_i128)]
+        fn to_u128 -> u128;
+
+        fn to_f32 -> f32;
+        fn to_f64 -> f64;
+    }
+}
+
+macro_rules! impl_from_primitive_wrapping {
+    ($( $(#[$cfg:meta])* fn $method:ident ( $i:ident ); )*) => {$(
+        #[inline]
+        $(#[$cfg])*
+        fn $method(n: $i) -> Option<Self> {
+            T::$method(n).map(Wrapping)
+        }
+    )*}
+}
+
+impl<T: FromPrimitive> FromPrimitive for Wrapping<T> {
+    impl_from_primitive_wrapping! {
+        fn from_isize(isize);
+        fn from_i8(i8);
+        fn from_i16(i16);
+        fn from_i32(i32);
+        fn from_i64(i64);
+        #[cfg(has_i128)]
+        fn from_i128(i128);
+
+        fn from_usize(usize);
+        fn from_u8(u8);
+        fn from_u16(u16);
+        fn from_u32(u32);
+        fn from_u64(u64);
+        #[cfg(has_i128)]
+        fn from_u128(u128);
+
+        fn from_f32(f32);
+        fn from_f64(f64);
+    }
+}
+
+/// Cast from one machine scalar to another.
+///
+/// # Examples
+///
+/// ```
+/// # use num_traits as num;
+/// let twenty: f32 = num::cast(0x14).unwrap();
+/// assert_eq!(twenty, 20f32);
+/// ```
+///
+#[inline]
+pub fn cast<T: NumCast, U: NumCast>(n: T) -> Option<U> {
+    NumCast::from(n)
+}
+
+/// An interface for casting between machine scalars.
+pub trait NumCast: Sized + ToPrimitive {
+    /// Creates a number from another value that can be converted into
+    /// a primitive via the `ToPrimitive` trait.
+    fn from<T: ToPrimitive>(n: T) -> Option<Self>;
+}
+
+macro_rules! impl_num_cast {
+    ($T:ty, $conv:ident) => {
+        impl NumCast for $T {
+            #[inline]
+            #[allow(deprecated)]
+            fn from<N: ToPrimitive>(n: N) -> Option<$T> {
+                // `$conv` could be generated using `concat_idents!`, but that
+                // macro seems to be broken at the moment
+                n.$conv()
+            }
+        }
+    };
+}
+
+impl_num_cast!(u8, to_u8);
+impl_num_cast!(u16, to_u16);
+impl_num_cast!(u32, to_u32);
+impl_num_cast!(u64, to_u64);
+#[cfg(has_i128)]
+impl_num_cast!(u128, to_u128);
+impl_num_cast!(usize, to_usize);
+impl_num_cast!(i8, to_i8);
+impl_num_cast!(i16, to_i16);
+impl_num_cast!(i32, to_i32);
+impl_num_cast!(i64, to_i64);
+#[cfg(has_i128)]
+impl_num_cast!(i128, to_i128);
+impl_num_cast!(isize, to_isize);
+impl_num_cast!(f32, to_f32);
+impl_num_cast!(f64, to_f64);
+
+impl<T: NumCast> NumCast for Wrapping<T> {
+    fn from<U: ToPrimitive>(n: U) -> Option<Self> {
+        T::from(n).map(Wrapping)
+    }
+}
+
+/// A generic interface for casting between machine scalars with the
+/// `as` operator, which admits narrowing and precision loss.
+/// Implementers of this trait `AsPrimitive` should behave like a primitive
+/// numeric type (e.g. a newtype around another primitive), and the
+/// intended conversion must never fail.
+///
+/// # Examples
+///
+/// ```
+/// # use num_traits::AsPrimitive;
+/// let three: i32 = (3.14159265f32).as_();
+/// assert_eq!(three, 3);
+/// ```
+///
+/// # Safety
+///
+/// Currently, some uses of the `as` operator are not entirely safe.
+/// In particular, it is undefined behavior if:
+///
+/// - A truncated floating point value cannot fit in the target integer
+///   type ([#10184](https://github.com/rust-lang/rust/issues/10184));
+///
+/// ```ignore
+/// # use num_traits::AsPrimitive;
+/// let x: u8 = (1.04E+17).as_(); // UB
+/// ```
+///
+/// - Or a floating point value does not fit in another floating
+///   point type ([#15536](https://github.com/rust-lang/rust/issues/15536)).
+///
+/// ```ignore
+/// # use num_traits::AsPrimitive;
+/// let x: f32 = (1e300f64).as_(); // UB
+/// ```
+///
+pub trait AsPrimitive<T>: 'static + Copy
+where
+    T: 'static + Copy,
+{
+    /// Convert a value to another, using the `as` operator.
+    fn as_(self) -> T;
+}
+
+macro_rules! impl_as_primitive {
+    (@ $T: ty => $(#[$cfg:meta])* impl $U: ty ) => {
+        $(#[$cfg])*
+        impl AsPrimitive<$U> for $T {
+            #[inline] fn as_(self) -> $U { self as $U }
+        }
+    };
+    (@ $T: ty => { $( $U: ty ),* } ) => {$(
+        impl_as_primitive!(@ $T => impl $U);
+    )*};
+    ($T: ty => { $( $U: ty ),* } ) => {
+        impl_as_primitive!(@ $T => { $( $U ),* });
+        impl_as_primitive!(@ $T => { u8, u16, u32, u64, usize });
+        impl_as_primitive!(@ $T => #[cfg(has_i128)] impl u128);
+        impl_as_primitive!(@ $T => { i8, i16, i32, i64, isize });
+        impl_as_primitive!(@ $T => #[cfg(has_i128)] impl i128);
+    };
+}
+
+impl_as_primitive!(u8 => { char, f32, f64 });
+impl_as_primitive!(i8 => { f32, f64 });
+impl_as_primitive!(u16 => { f32, f64 });
+impl_as_primitive!(i16 => { f32, f64 });
+impl_as_primitive!(u32 => { f32, f64 });
+impl_as_primitive!(i32 => { f32, f64 });
+impl_as_primitive!(u64 => { f32, f64 });
+impl_as_primitive!(i64 => { f32, f64 });
+#[cfg(has_i128)]
+impl_as_primitive!(u128 => { f32, f64 });
+#[cfg(has_i128)]
+impl_as_primitive!(i128 => { f32, f64 });
+impl_as_primitive!(usize => { f32, f64 });
+impl_as_primitive!(isize => { f32, f64 });
+impl_as_primitive!(f32 => { f32, f64 });
+impl_as_primitive!(f64 => { f32, f64 });
+impl_as_primitive!(char => { char });
+impl_as_primitive!(bool => {});

src/identities.rs

@@ -0,0 +1,207 @@
+use core::num::Wrapping;
+use core::ops::{Add, Mul};
+
+/// Defines an additive identity element for `Self`.
+///
+/// # Laws
+///
+/// ```{.text}
+/// a + 0 = a       ∀ a ∈ Self
+/// 0 + a = a       ∀ a ∈ Self
+/// ```
+pub trait Zero: Sized + Add<Self, Output = Self> {
+    /// Returns the additive identity element of `Self`, `0`.
+    /// # Purity
+    ///
+    /// This function should return the same result at all times regardless of
+    /// external mutable state, for example values stored in TLS or in
+    /// `static mut`s.
+    // This cannot be an associated constant, because of bignums.
+    fn zero() -> Self;
+
+    /// Sets `self` to the additive identity element of `Self`, `0`.
+    fn set_zero(&mut self) {
+        *self = Zero::zero();
+    }
+
+    /// Returns `true` if `self` is equal to the additive identity.
+    #[inline]
+    fn is_zero(&self) -> bool;
+}
+
+macro_rules! zero_impl {
+    ($t:ty, $v:expr) => {
+        impl Zero for $t {
+            #[inline]
+            fn zero() -> $t {
+                $v
+            }
+            #[inline]
+            fn is_zero(&self) -> bool {
+                *self == $v
+            }
+        }
+    };
+}
+
+zero_impl!(usize, 0);
+zero_impl!(u8, 0);
+zero_impl!(u16, 0);
+zero_impl!(u32, 0);
+zero_impl!(u64, 0);
+#[cfg(has_i128)]
+zero_impl!(u128, 0);
+
+zero_impl!(isize, 0);
+zero_impl!(i8, 0);
+zero_impl!(i16, 0);
+zero_impl!(i32, 0);
+zero_impl!(i64, 0);
+#[cfg(has_i128)]
+zero_impl!(i128, 0);
+
+zero_impl!(f32, 0.0);
+zero_impl!(f64, 0.0);
+
+impl<T: Zero> Zero for Wrapping<T>
+where
+    Wrapping<T>: Add<Output = Wrapping<T>>,
+{
+    fn is_zero(&self) -> bool {
+        self.0.is_zero()
+    }
+
+    fn set_zero(&mut self) {
+        self.0.set_zero();
+    }
+
+    fn zero() -> Self {
+        Wrapping(T::zero())
+    }
+}
+
+/// Defines a multiplicative identity element for `Self`.
+///
+/// # Laws
+///
+/// ```{.text}
+/// a * 1 = a       ∀ a ∈ Self
+/// 1 * a = a       ∀ a ∈ Self
+/// ```
+pub trait One: Sized + Mul<Self, Output = Self> {
+    /// Returns the multiplicative identity element of `Self`, `1`.
+    ///
+    /// # Purity
+    ///
+    /// This function should return the same result at all times regardless of
+    /// external mutable state, for example values stored in TLS or in
+    /// `static mut`s.
+    // This cannot be an associated constant, because of bignums.
+    fn one() -> Self;
+
+    /// Sets `self` to the multiplicative identity element of `Self`, `1`.
+    fn set_one(&mut self) {
+        *self = One::one();
+    }
+
+    /// Returns `true` if `self` is equal to the multiplicative identity.
+    ///
+    /// For performance reasons, it's best to implement this manually.
+    /// After a semver bump, this method will be required, and the
+    /// `where Self: PartialEq` bound will be removed.
+    #[inline]
+    fn is_one(&self) -> bool
+    where
+        Self: PartialEq,
+    {
+        *self == Self::one()
+    }
+}
+
+macro_rules! one_impl {
+    ($t:ty, $v:expr) => {
+        impl One for $t {
+            #[inline]
+            fn one() -> $t {
+                $v
+            }
+            #[inline]
+            fn is_one(&self) -> bool {
+                *self == $v
+            }
+        }
+    };
+}
+
+one_impl!(usize, 1);
+one_impl!(u8, 1);
+one_impl!(u16, 1);
+one_impl!(u32, 1);
+one_impl!(u64, 1);
+#[cfg(has_i128)]
+one_impl!(u128, 1);
+
+one_impl!(isize, 1);
+one_impl!(i8, 1);
+one_impl!(i16, 1);
+one_impl!(i32, 1);
+one_impl!(i64, 1);
+#[cfg(has_i128)]
+one_impl!(i128, 1);
+
+one_impl!(f32, 1.0);
+one_impl!(f64, 1.0);
+
+impl<T: One> One for Wrapping<T>
+where
+    Wrapping<T>: Mul<Output = Wrapping<T>>,
+{
+    fn set_one(&mut self) {
+        self.0.set_one();
+    }
+
+    fn one() -> Self {
+        Wrapping(T::one())
+    }
+}
+
+// Some helper functions provided for backwards compatibility.
+
+/// Returns the additive identity, `0`.
+#[inline(always)]
+pub fn zero<T: Zero>() -> T {
+    Zero::zero()
+}
+
+/// Returns the multiplicative identity, `1`.
+#[inline(always)]
+pub fn one<T: One>() -> T {
+    One::one()
+}
+
+#[test]
+fn wrapping_identities() {
+    macro_rules! test_wrapping_identities {
+        ($($t:ty)+) => {
+            $(
+                assert_eq!(zero::<$t>(), zero::<Wrapping<$t>>().0);
+                assert_eq!(one::<$t>(), one::<Wrapping<$t>>().0);
+                assert_eq!((0 as $t).is_zero(), Wrapping(0 as $t).is_zero());
+                assert_eq!((1 as $t).is_zero(), Wrapping(1 as $t).is_zero());
+            )+
+        };
+    }
+
+    test_wrapping_identities!(isize i8 i16 i32 i64 usize u8 u16 u32 u64);
+}
+
+#[test]
+fn wrapping_is_zero() {
+    fn require_zero<T: Zero>(_: &T) {}
+    require_zero(&Wrapping(42));
+}
+#[test]
+fn wrapping_is_one() {
+    fn require_one<T: One>(_: &T) {}
+    require_one(&Wrapping(42));
+}

src/int.rs

@@ -1,26 +1,55 @@
-use std::ops::{Not, BitAnd, BitOr, BitXor, Shl, Shr};
+use core::ops::{BitAnd, BitOr, BitXor, Not, Shl, Shr};
 
-use {Num, NumCast};
 use bounds::Bounded;
 use ops::checked::*;
 use ops::saturating::Saturating;
+use {Num, NumCast};
 
-pub trait PrimInt
-    : Sized
+/// Generic trait for primitive integers.
+///
+/// The `PrimInt` trait is an abstraction over the builtin primitive integer types (e.g., `u8`,
+/// `u32`, `isize`, `i128`, ...). It inherits the basic numeric traits and extends them with
+/// bitwise operators and non-wrapping arithmetic.
+///
+/// The trait explicitly inherits `Copy`, `Eq`, `Ord`, and `Sized`. The intention is that all
+/// types implementing this trait behave like primitive types that are passed by value by default
+/// and behave like builtin integers. Furthermore, the types are expected to expose the integer
+/// value in binary representation and support bitwise operators. The standard bitwise operations
+/// (e.g., bitwise-and, bitwise-or, right-shift, left-shift) are inherited and the trait extends
+/// these with introspective queries (e.g., `PrimInt::count_ones()`, `PrimInt::leading_zeros()`),
+/// bitwise combinators (e.g., `PrimInt::rotate_left()`), and endianness converters (e.g.,
+/// `PrimInt::to_be()`).
+///
+/// All `PrimInt` types are expected to be fixed-width binary integers. The width can be queried
+/// via `T::zero().count_zeros()`. The trait currently lacks a way to query the width at
+/// compile-time.
+///
+/// While a default implementation for all builtin primitive integers is provided, the trait is in
+/// no way restricted to these. Other integer types that fulfil the requirements are free to
+/// implement the trait was well.
+///
+/// This trait and many of the method names originate in the unstable `core::num::Int` trait from
+/// the rust standard library. The original trait was never stabilized and thus removed from the
+/// standard library.
+pub trait PrimInt:
+    Sized
     + Copy
-    + Num + NumCast
+    + Num
+    + NumCast
     + Bounded
-    + PartialOrd + Ord + Eq
-    + Not<Output=Self>
-    + BitAnd<Output=Self>
-    + BitOr<Output=Self>
-    + BitXor<Output=Self>
-    + Shl<usize, Output=Self>
-    + Shr<usize, Output=Self>
-    + CheckedAdd<Output=Self>
-    + CheckedSub<Output=Self>
-    + CheckedMul<Output=Self>
-    + CheckedDiv<Output=Self>
+    + PartialOrd
+    + Ord
+    + Eq
+    + Not<Output = Self>
+    + BitAnd<Output = Self>
+    + BitOr<Output = Self>
+    + BitXor<Output = Self>
+    + Shl<usize, Output = Self>
+    + Shr<usize, Output = Self>
+    + CheckedAdd<Output = Self>
+    + CheckedSub<Output = Self>
+    + CheckedMul<Output = Self>
+    + CheckedDiv<Output = Self>
     + Saturating
 {
     /// Returns the number of ones in the binary representation of `self`.
@@ -168,10 +197,10 @@ pub trait PrimInt
     /// ```
     /// use num_traits::PrimInt;
     ///
-    /// let n = 0xFEDCBA9876543210i64;
-    /// let m = 0x000FEDCBA9876543i64;
+    /// let n = -8i8; // 0b11111000
+    /// let m = 62i8; // 0b00111110
     ///
-    /// assert_eq!(n.unsigned_shr(12), m);
+    /// assert_eq!(n.unsigned_shr(2), m);
     /// ```
     fn unsigned_shr(self, n: u32) -> Self;
 
@@ -274,11 +303,11 @@ pub trait PrimInt
     ///
     /// assert_eq!(2i32.pow(4), 16);
     /// ```
-    fn pow(self, mut exp: u32) -> Self;
+    fn pow(self, exp: u32) -> Self;
 }
 
 macro_rules! prim_int_impl {
-    ($T:ty, $S:ty, $U:ty) => (
+    ($T:ty, $S:ty, $U:ty) => {
         impl PrimInt for $T {
             #[inline]
             fn count_ones(self) -> u32 {
@@ -360,17 +389,21 @@ macro_rules! prim_int_impl {
                 <$T>::pow(self, exp)
             }
         }
-    )
+    };
 }
 
 // prim_int_impl!(type, signed, unsigned);
-prim_int_impl!(u8,    i8,    u8);
-prim_int_impl!(u16,   i16,   u16);
-prim_int_impl!(u32,   i32,   u32);
-prim_int_impl!(u64,   i64,   u64);
+prim_int_impl!(u8, i8, u8);
+prim_int_impl!(u16, i16, u16);
+prim_int_impl!(u32, i32, u32);
+prim_int_impl!(u64, i64, u64);
+#[cfg(has_i128)]
+prim_int_impl!(u128, i128, u128);
 prim_int_impl!(usize, isize, usize);
-prim_int_impl!(i8,    i8,    u8);
-prim_int_impl!(i16,   i16,   u16);
-prim_int_impl!(i32,   i32,   u32);
-prim_int_impl!(i64,   i64,   u64);
+prim_int_impl!(i8, i8, u8);
+prim_int_impl!(i16, i16, u16);
+prim_int_impl!(i32, i32, u32);
+prim_int_impl!(i64, i64, u64);
+#[cfg(has_i128)]
+prim_int_impl!(i128, i128, u128);
 prim_int_impl!(isize, isize, usize);

src/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2014-2016 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,104 +8,565 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! A collection of numeric types and traits for Rust.
+//! Numeric traits for generic mathematics
 //!
-//! 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.
+//! ## Compatibility
 //!
-//! ## Example
-//!
-//! This example uses the BigRational type and [Newton's method][newt] 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
-//! }
-//!
-//! ```
-//!
-//! [newt]: https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method
-#![doc(html_logo_url = "http://rust-num.github.io/num/rust-logo-128x128-blk-v2.png",
-       html_favicon_url = "http://rust-num.github.io/num/favicon.ico",
-       html_root_url = "http://rust-num.github.io/num/",
-       html_playground_url = "http://play.rust-lang.org/")]
+//! The `num-traits` crate is tested for rustc 1.8 and greater.
 
-extern crate num_traits;
-extern crate num_integer;
-extern crate num_iter;
-#[cfg(feature = "num-complex")]
-extern crate num_complex;
-#[cfg(feature = "num-bigint")]
-extern crate num_bigint;
-#[cfg(feature = "num-rational")]
-extern crate num_rational;
+#![doc(html_root_url = "https://docs.rs/num-traits/0.2")]
+#![deny(unconditional_recursion)]
+#![no_std]
+#[cfg(feature = "std")]
+extern crate std;
 
-#[cfg(feature = "num-bigint")]
-pub use num_bigint::{BigInt, BigUint};
-#[cfg(feature = "num-rational")]
-pub use num_rational::Rational;
-#[cfg(all(feature = "num-rational", feature="num-bigint"))]
-pub use num_rational::BigRational;
-#[cfg(feature = "num-complex")]
-pub use num_complex::Complex;
-pub use num_integer::Integer;
-pub use num_iter::{range, range_inclusive, range_step, range_step_inclusive};
-pub use num_traits::{Num, Zero, One, Signed, Unsigned, Bounded,
-                     one, zero, abs, abs_sub, signum,
-                     Saturating, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv,
-                     PrimInt, Float, ToPrimitive, FromPrimitive, NumCast, cast,
-                     pow, checked_pow};
+// Only `no_std` builds actually use `libm`.
+#[cfg(all(not(feature = "std"), feature = "libm"))]
+extern crate libm;
 
-#[cfg(feature = "num-bigint")]
-pub mod bigint {
-    pub use num_bigint::*;
+use core::fmt;
+use core::num::Wrapping;
+use core::ops::{Add, Div, Mul, Rem, Sub};
+use core::ops::{AddAssign, DivAssign, MulAssign, RemAssign, SubAssign};
+
+pub use bounds::Bounded;
+#[cfg(any(feature = "std", feature = "libm"))]
+pub use float::Float;
+pub use float::FloatConst;
+// pub use real::{FloatCore, Real}; // NOTE: Don't do this, it breaks `use num_traits::*;`.
+pub use cast::{cast, AsPrimitive, FromPrimitive, NumCast, ToPrimitive};
+pub use identities::{one, zero, One, Zero};
+pub use int::PrimInt;
+pub use ops::checked::{
+    CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedRem, CheckedShl, CheckedShr, CheckedSub,
+};
+pub use ops::inv::Inv;
+pub use ops::mul_add::{MulAdd, MulAddAssign};
+pub use ops::saturating::Saturating;
+pub use ops::wrapping::{WrappingAdd, WrappingMul, WrappingShl, WrappingShr, WrappingSub};
+pub use pow::{checked_pow, pow, Pow};
+pub use sign::{abs, abs_sub, signum, Signed, Unsigned};
+
+#[macro_use]
+mod macros;
+
+pub mod bounds;
+pub mod cast;
+pub mod float;
+pub mod identities;
+pub mod int;
+pub mod ops;
+pub mod pow;
+pub mod real;
+pub mod sign;
+
+/// The base trait for numeric types, covering `0` and `1` values,
+/// comparisons, basic numeric operations, and string conversion.
+pub trait Num: PartialEq + Zero + One + NumOps {
+    type FromStrRadixErr;
+
+    /// Convert from a string and radix <= 36.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// use num_traits::Num;
+    ///
+    /// let result = <i32 as Num>::from_str_radix("27", 10);
+    /// assert_eq!(result, Ok(27));
+    ///
+    /// let result = <i32 as Num>::from_str_radix("foo", 10);
+    /// assert!(result.is_err());
+    /// ```
+    fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>;
 }
 
-#[cfg(feature = "num-complex")]
-pub mod complex {
-    pub use num_complex::*;
+/// The trait for types implementing basic numeric operations
+///
+/// This is automatically implemented for types which implement the operators.
+pub trait NumOps<Rhs = Self, Output = Self>:
+    Add<Rhs, Output = Output>
+    + Sub<Rhs, Output = Output>
+    + Mul<Rhs, Output = Output>
+    + Div<Rhs, Output = Output>
+    + Rem<Rhs, Output = Output>
+{
 }
 
-pub mod integer {
-    pub use num_integer::*;
+impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
+    T: Add<Rhs, Output = Output>
+        + Sub<Rhs, Output = Output>
+        + Mul<Rhs, Output = Output>
+        + Div<Rhs, Output = Output>
+        + Rem<Rhs, Output = Output>
+{
 }
 
-pub mod iter {
-    pub use num_iter::*;
+/// The trait for `Num` types which also implement numeric operations taking
+/// the second operand by reference.
+///
+/// This is automatically implemented for types which implement the operators.
+pub trait NumRef: Num + for<'r> NumOps<&'r Self> {}
+impl<T> NumRef for T where T: Num + for<'r> NumOps<&'r T> {}
+
+/// The trait for references which implement numeric operations, taking the
+/// second operand either by value or by reference.
+///
+/// This is automatically implemented for types which implement the operators.
+pub trait RefNum<Base>: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
+impl<T, Base> RefNum<Base> for T where T: NumOps<Base, Base> + for<'r> NumOps<&'r Base, Base> {}
+
+/// The trait for types implementing numeric assignment operators (like `+=`).
+///
+/// This is automatically implemented for types which implement the operators.
+pub trait NumAssignOps<Rhs = Self>:
+    AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>
+{
 }
 
-pub mod traits {
-    pub use num_traits::*;
+impl<T, Rhs> NumAssignOps<Rhs> for T where
+    T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>
+{
 }
 
-#[cfg(feature = "num-rational")]
-pub mod rational {
-    pub use num_rational::*;
+/// The trait for `Num` types which also implement assignment operators.
+///
+/// This is automatically implemented for types which implement the operators.
+pub trait NumAssign: Num + NumAssignOps {}
+impl<T> NumAssign for T where T: Num + NumAssignOps {}
+
+/// The trait for `NumAssign` types which also implement assignment operations
+/// taking the second operand by reference.
+///
+/// This is automatically implemented for types which implement the operators.
+pub trait NumAssignRef: NumAssign + for<'r> NumAssignOps<&'r Self> {}
+impl<T> NumAssignRef for T where T: NumAssign + for<'r> NumAssignOps<&'r T> {}
+
+macro_rules! int_trait_impl {
+    ($name:ident for $($t:ty)*) => ($(
+        impl $name for $t {
+            type FromStrRadixErr = ::core::num::ParseIntError;
+            #[inline]
+            fn from_str_radix(s: &str, radix: u32)
+                              -> Result<Self, ::core::num::ParseIntError>
+            {
+                <$t>::from_str_radix(s, radix)
+            }
+        }
+    )*)
 }
+int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+#[cfg(has_i128)]
+int_trait_impl!(Num for u128 i128);
+
+impl<T: Num> Num for Wrapping<T>
+where
+    Wrapping<T>: Add<Output = Wrapping<T>>
+        + Sub<Output = Wrapping<T>>
+        + Mul<Output = Wrapping<T>>
+        + Div<Output = Wrapping<T>>
+        + Rem<Output = Wrapping<T>>,
+{
+    type FromStrRadixErr = T::FromStrRadixErr;
+    fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr> {
+        T::from_str_radix(str, radix).map(Wrapping)
+    }
+}
+
+#[derive(Debug)]
+pub enum FloatErrorKind {
+    Empty,
+    Invalid,
+}
+// FIXME: core::num::ParseFloatError is stable in 1.0, but opaque to us,
+// so there's not really any way for us to reuse it.
+#[derive(Debug)]
+pub struct ParseFloatError {
+    pub kind: FloatErrorKind,
+}
+
+impl fmt::Display for ParseFloatError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let description = match self.kind {
+            FloatErrorKind::Empty => "cannot parse float from empty string",
+            FloatErrorKind::Invalid => "invalid float literal",
+        };
+
+        description.fmt(f)
+    }
+}
+
+// FIXME: The standard library from_str_radix on floats was deprecated, so we're stuck
+// with this implementation ourselves until we want to make a breaking change.
+// (would have to drop it from `Num` though)
+macro_rules! float_trait_impl {
+    ($name:ident for $($t:ident)*) => ($(
+        impl $name for $t {
+            type FromStrRadixErr = ParseFloatError;
+
+            fn from_str_radix(src: &str, radix: u32)
+                              -> Result<Self, Self::FromStrRadixErr>
+            {
+                use self::FloatErrorKind::*;
+                use self::ParseFloatError as PFE;
+
+                // Special values
+                match src {
+                    "inf"   => return Ok(core::$t::INFINITY),
+                    "-inf"  => return Ok(core::$t::NEG_INFINITY),
+                    "NaN"   => return Ok(core::$t::NAN),
+                    _       => {},
+                }
+
+                fn slice_shift_char(src: &str) -> Option<(char, &str)> {
+                    let mut chars = src.chars();
+                    if let Some(ch) = chars.next() {
+                        Some((ch, chars.as_str()))
+                    } else {
+                        None
+                    }
+                }
+
+                let (is_positive, src) =  match slice_shift_char(src) {
+                    None             => return Err(PFE { kind: Empty }),
+                    Some(('-', ""))  => return Err(PFE { kind: Empty }),
+                    Some(('-', src)) => (false, src),
+                    Some((_, _))     => (true,  src),
+                };
+
+                // The significand to accumulate
+                let mut sig = if is_positive { 0.0 } else { -0.0 };
+                // Necessary to detect overflow
+                let mut prev_sig = sig;
+                let mut cs = src.chars().enumerate();
+                // Exponent prefix and exponent index offset
+                let mut exp_info = None::<(char, usize)>;
+
+                // Parse the integer part of the significand
+                for (i, c) in cs.by_ref() {
+                    match c.to_digit(radix) {
+                        Some(digit) => {
+                            // shift significand one digit left
+                            sig = sig * (radix as $t);
+
+                            // add/subtract current digit depending on sign
+                            if is_positive {
+                                sig = sig + ((digit as isize) as $t);
+                            } else {
+                                sig = sig - ((digit as isize) as $t);
+                            }
+
+                            // Detect overflow by comparing to last value, except
+                            // if we've not seen any non-zero digits.
+                            if prev_sig != 0.0 {
+                                if is_positive && sig <= prev_sig
+                                    { return Ok(core::$t::INFINITY); }
+                                if !is_positive && sig >= prev_sig
+                                    { return Ok(core::$t::NEG_INFINITY); }
+
+                                // Detect overflow by reversing the shift-and-add process
+                                if is_positive && (prev_sig != (sig - digit as $t) / radix as $t)
+                                    { return Ok(core::$t::INFINITY); }
+                                if !is_positive && (prev_sig != (sig + digit as $t) / radix as $t)
+                                    { return Ok(core::$t::NEG_INFINITY); }
+                            }
+                            prev_sig = sig;
+                        },
+                        None => match c {
+                            'e' | 'E' | 'p' | 'P' => {
+                                exp_info = Some((c, i + 1));
+                                break;  // start of exponent
+                            },
+                            '.' => {
+                                break;  // start of fractional part
+                            },
+                            _ => {
+                                return Err(PFE { kind: Invalid });
+                            },
+                        },
+                    }
+                }
+
+                // If we are not yet at the exponent parse the fractional
+                // part of the significand
+                if exp_info.is_none() {
+                    let mut power = 1.0;
+                    for (i, c) in cs.by_ref() {
+                        match c.to_digit(radix) {
+                            Some(digit) => {
+                                // Decrease power one order of magnitude
+                                power = power / (radix as $t);
+                                // add/subtract current digit depending on sign
+                                sig = if is_positive {
+                                    sig + (digit as $t) * power
+                                } else {
+                                    sig - (digit as $t) * power
+                                };
+                                // Detect overflow by comparing to last value
+                                if is_positive && sig < prev_sig
+                                    { return Ok(core::$t::INFINITY); }
+                                if !is_positive && sig > prev_sig
+                                    { return Ok(core::$t::NEG_INFINITY); }
+                                prev_sig = sig;
+                            },
+                            None => match c {
+                                'e' | 'E' | 'p' | 'P' => {
+                                    exp_info = Some((c, i + 1));
+                                    break; // start of exponent
+                                },
+                                _ => {
+                                    return Err(PFE { kind: Invalid });
+                                },
+                            },
+                        }
+                    }
+                }
+
+                // Parse and calculate the exponent
+                let exp = match exp_info {
+                    Some((c, offset)) => {
+                        let base = match c {
+                            'E' | 'e' if radix == 10 => 10.0,
+                            'P' | 'p' if radix == 16 => 2.0,
+                            _ => return Err(PFE { kind: Invalid }),
+                        };
+
+                        // Parse the exponent as decimal integer
+                        let src = &src[offset..];
+                        let (is_positive, exp) = match slice_shift_char(src) {
+                            Some(('-', src)) => (false, src.parse::<usize>()),
+                            Some(('+', src)) => (true,  src.parse::<usize>()),
+                            Some((_, _))     => (true,  src.parse::<usize>()),
+                            None             => return Err(PFE { kind: Invalid }),
+                        };
+
+                        #[cfg(feature = "std")]
+                        fn pow(base: $t, exp: usize) -> $t {
+                            Float::powi(base, exp as i32)
+                        }
+                        // otherwise uses the generic `pow` from the root
+
+                        match (is_positive, exp) {
+                            (true,  Ok(exp)) => pow(base, exp),
+                            (false, Ok(exp)) => 1.0 / pow(base, exp),
+                            (_, Err(_))      => return Err(PFE { kind: Invalid }),
+                        }
+                    },
+                    None => 1.0, // no exponent
+                };
+
+                Ok(sig * exp)
+            }
+        }
+    )*)
+}
+float_trait_impl!(Num for f32 f64);
+
+/// A value bounded by a minimum and a maximum
+///
+///  If input is less than min then this returns min.
+///  If input is greater than max then this returns max.
+///  Otherwise this returns input.
+///
+/// **Panics** in debug mode if `!(min <= max)`.
+#[inline]
+pub fn clamp<T: PartialOrd>(input: T, min: T, max: T) -> T {
+    debug_assert!(min <= max, "min must be less than or equal to max");
+    if input < min {
+        min
+    } else if input > max {
+        max
+    } else {
+        input
+    }
+}
+
+/// A value bounded by a minimum value
+///
+///  If input is less than min then this returns min.
+///  Otherwise this returns input.
+///  `clamp_min(std::f32::NAN, 1.0)` preserves `NAN` different from `f32::min(std::f32::NAN, 1.0)`.
+///
+/// **Panics** in debug mode if `!(min == min)`. (This occurs if `min` is `NAN`.)
+#[inline]
+pub fn clamp_min<T: PartialOrd>(input: T, min: T) -> T {
+    debug_assert!(min == min, "min must not be NAN");
+    if input < min {
+        min
+    } else {
+        input
+    }
+}
+
+/// A value bounded by a maximum value
+///
+///  If input is greater than max then this returns max.
+///  Otherwise this returns input.
+///  `clamp_max(std::f32::NAN, 1.0)` preserves `NAN` different from `f32::max(std::f32::NAN, 1.0)`.
+///
+/// **Panics** in debug mode if `!(max == max)`. (This occurs if `max` is `NAN`.)
+#[inline]
+pub fn clamp_max<T: PartialOrd>(input: T, max: T) -> T {
+    debug_assert!(max == max, "max must not be NAN");
+    if input > max {
+        max
+    } else {
+        input
+    }
+}
+
+#[test]
+fn clamp_test() {
+    // Int test
+    assert_eq!(1, clamp(1, -1, 2));
+    assert_eq!(-1, clamp(-2, -1, 2));
+    assert_eq!(2, clamp(3, -1, 2));
+    assert_eq!(1, clamp_min(1, -1));
+    assert_eq!(-1, clamp_min(-2, -1));
+    assert_eq!(-1, clamp_max(1, -1));
+    assert_eq!(-2, clamp_max(-2, -1));
+
+    // Float test
+    assert_eq!(1.0, clamp(1.0, -1.0, 2.0));
+    assert_eq!(-1.0, clamp(-2.0, -1.0, 2.0));
+    assert_eq!(2.0, clamp(3.0, -1.0, 2.0));
+    assert_eq!(1.0, clamp_min(1.0, -1.0));
+    assert_eq!(-1.0, clamp_min(-2.0, -1.0));
+    assert_eq!(-1.0, clamp_max(1.0, -1.0));
+    assert_eq!(-2.0, clamp_max(-2.0, -1.0));
+    assert!(clamp(::core::f32::NAN, -1.0, 1.0).is_nan());
+    assert!(clamp_min(::core::f32::NAN, 1.0).is_nan());
+    assert!(clamp_max(::core::f32::NAN, 1.0).is_nan());
+}
+
+#[test]
+#[should_panic]
+#[cfg(debug_assertions)]
+fn clamp_nan_min() {
+    clamp(0., ::core::f32::NAN, 1.);
+}
+
+#[test]
+#[should_panic]
+#[cfg(debug_assertions)]
+fn clamp_nan_max() {
+    clamp(0., -1., ::core::f32::NAN);
+}
+
+#[test]
+#[should_panic]
+#[cfg(debug_assertions)]
+fn clamp_nan_min_max() {
+    clamp(0., ::core::f32::NAN, ::core::f32::NAN);
+}
+
+#[test]
+#[should_panic]
+#[cfg(debug_assertions)]
+fn clamp_min_nan_min() {
+    clamp_min(0., ::core::f32::NAN);
+}
+
+#[test]
+#[should_panic]
+#[cfg(debug_assertions)]
+fn clamp_max_nan_max() {
+    clamp_max(0., ::core::f32::NAN);
+}
+
+#[test]
+fn from_str_radix_unwrap() {
+    // The Result error must impl Debug to allow unwrap()
+
+    let i: i32 = Num::from_str_radix("0", 10).unwrap();
+    assert_eq!(i, 0);
+
+    let f: f32 = Num::from_str_radix("0.0", 10).unwrap();
+    assert_eq!(f, 0.0);
+}
+
+#[test]
+fn from_str_radix_multi_byte_fail() {
+    // Ensure parsing doesn't panic, even on invalid sign characters
+    assert!(f32::from_str_radix("™0.2", 10).is_err());
+
+    // Even when parsing the exponent sign
+    assert!(f32::from_str_radix("0.2E™1", 10).is_err());
+}
+
+#[test]
+fn wrapping_is_num() {
+    fn require_num<T: Num>(_: &T) {}
+    require_num(&Wrapping(42_u32));
+    require_num(&Wrapping(-42));
+}
+
+#[test]
+fn wrapping_from_str_radix() {
+    macro_rules! test_wrapping_from_str_radix {
+        ($($t:ty)+) => {
+            $(
+                for &(s, r) in &[("42", 10), ("42", 2), ("-13.0", 10), ("foo", 10)] {
+                    let w = Wrapping::<$t>::from_str_radix(s, r).map(|w| w.0);
+                    assert_eq!(w, <$t as Num>::from_str_radix(s, r));
+                }
+            )+
+        };
+    }
+
+    test_wrapping_from_str_radix!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn check_num_ops() {
+    fn compute<T: Num + Copy>(x: T, y: T) -> T {
+        x * y / y % y + y - y
+    }
+    assert_eq!(compute(1, 2), 1)
+}
+
+#[test]
+fn check_numref_ops() {
+    fn compute<T: NumRef>(x: T, y: &T) -> T {
+        x * y / y % y + y - y
+    }
+    assert_eq!(compute(1, &2), 1)
+}
+
+#[test]
+fn check_refnum_ops() {
+    fn compute<T: Copy>(x: &T, y: T) -> T
+    where
+        for<'a> &'a T: RefNum<T>,
+    {
+        &(&(&(&(x * y) / y) % y) + y) - y
+    }
+    assert_eq!(compute(&1, 2), 1)
+}
+
+#[test]
+fn check_refref_ops() {
+    fn compute<T>(x: &T, y: &T) -> T
+    where
+        for<'a> &'a T: RefNum<T>,
+    {
+        &(&(&(&(x * y) / y) % y) + y) - y
+    }
+    assert_eq!(compute(&1, &2), 1)
+}
+
+#[test]
+fn check_numassign_ops() {
+    fn compute<T: NumAssign + Copy>(mut x: T, y: T) -> T {
+        x *= y;
+        x /= y;
+        x %= y;
+        x += y;
+        x -= y;
+        x
+    }
+    assert_eq!(compute(1, 2), 1)
+}
+
+// TODO test `NumAssignRef`, but even the standard numeric types don't
+// implement this yet. (see rust pr41336)

src/macros.rs

@@ -0,0 +1,37 @@
+// not all are used in all features configurations
+#![allow(unused)]
+
+/// Forward a method to an inherent method or a base trait method.
+macro_rules! forward {
+    ($( Self :: $method:ident ( self $( , $arg:ident : $ty:ty )* ) -> $ret:ty ; )*)
+        => {$(
+            #[inline]
+            fn $method(self $( , $arg : $ty )* ) -> $ret {
+                Self::$method(self $( , $arg )* )
+            }
+        )*};
+    ($( $base:ident :: $method:ident ( self $( , $arg:ident : $ty:ty )* ) -> $ret:ty ; )*)
+        => {$(
+            #[inline]
+            fn $method(self $( , $arg : $ty )* ) -> $ret {
+                <Self as $base>::$method(self $( , $arg )* )
+            }
+        )*};
+    ($( $base:ident :: $method:ident ( $( $arg:ident : $ty:ty ),* ) -> $ret:ty ; )*)
+        => {$(
+            #[inline]
+            fn $method( $( $arg : $ty ),* ) -> $ret {
+                <Self as $base>::$method( $( $arg ),* )
+            }
+        )*}
+}
+
+macro_rules! constant {
+    ($( $method:ident () -> $ret:expr ; )*)
+        => {$(
+            #[inline]
+            fn $method() -> Self {
+                $ret
+            }
+        )*};
+}

src/ops/checked.rs

@@ -0,0 +1,277 @@
+use core::ops::{Add, Div, Mul, Rem, Shl, Shr, Sub};
+
+/// Performs addition that returns `None` instead of wrapping around on
+/// overflow.
+pub trait CheckedAdd: Sized + Add<Self, Output = Self> {
+    /// Adds two numbers, checking for overflow. If overflow happens, `None` is
+    /// returned.
+    fn checked_add(&self, v: &Self) -> Option<Self>;
+}
+
+macro_rules! checked_impl {
+    ($trait_name:ident, $method:ident, $t:ty) => {
+        impl $trait_name for $t {
+            #[inline]
+            fn $method(&self, v: &$t) -> Option<$t> {
+                <$t>::$method(*self, *v)
+            }
+        }
+    };
+}
+
+checked_impl!(CheckedAdd, checked_add, u8);
+checked_impl!(CheckedAdd, checked_add, u16);
+checked_impl!(CheckedAdd, checked_add, u32);
+checked_impl!(CheckedAdd, checked_add, u64);
+checked_impl!(CheckedAdd, checked_add, usize);
+#[cfg(has_i128)]
+checked_impl!(CheckedAdd, checked_add, u128);
+
+checked_impl!(CheckedAdd, checked_add, i8);
+checked_impl!(CheckedAdd, checked_add, i16);
+checked_impl!(CheckedAdd, checked_add, i32);
+checked_impl!(CheckedAdd, checked_add, i64);
+checked_impl!(CheckedAdd, checked_add, isize);
+#[cfg(has_i128)]
+checked_impl!(CheckedAdd, checked_add, i128);
+
+/// Performs subtraction that returns `None` instead of wrapping around on underflow.
+pub trait CheckedSub: Sized + Sub<Self, Output = Self> {
+    /// Subtracts two numbers, checking for underflow. If underflow happens,
+    /// `None` is returned.
+    fn checked_sub(&self, v: &Self) -> Option<Self>;
+}
+
+checked_impl!(CheckedSub, checked_sub, u8);
+checked_impl!(CheckedSub, checked_sub, u16);
+checked_impl!(CheckedSub, checked_sub, u32);
+checked_impl!(CheckedSub, checked_sub, u64);
+checked_impl!(CheckedSub, checked_sub, usize);
+#[cfg(has_i128)]
+checked_impl!(CheckedSub, checked_sub, u128);
+
+checked_impl!(CheckedSub, checked_sub, i8);
+checked_impl!(CheckedSub, checked_sub, i16);
+checked_impl!(CheckedSub, checked_sub, i32);
+checked_impl!(CheckedSub, checked_sub, i64);
+checked_impl!(CheckedSub, checked_sub, isize);
+#[cfg(has_i128)]
+checked_impl!(CheckedSub, checked_sub, i128);
+
+/// Performs multiplication that returns `None` instead of wrapping around on underflow or
+/// overflow.
+pub trait CheckedMul: Sized + Mul<Self, Output = Self> {
+    /// Multiplies two numbers, checking for underflow or overflow. If underflow
+    /// or overflow happens, `None` is returned.
+    fn checked_mul(&self, v: &Self) -> Option<Self>;
+}
+
+checked_impl!(CheckedMul, checked_mul, u8);
+checked_impl!(CheckedMul, checked_mul, u16);
+checked_impl!(CheckedMul, checked_mul, u32);
+checked_impl!(CheckedMul, checked_mul, u64);
+checked_impl!(CheckedMul, checked_mul, usize);
+#[cfg(has_i128)]
+checked_impl!(CheckedMul, checked_mul, u128);
+
+checked_impl!(CheckedMul, checked_mul, i8);
+checked_impl!(CheckedMul, checked_mul, i16);
+checked_impl!(CheckedMul, checked_mul, i32);
+checked_impl!(CheckedMul, checked_mul, i64);
+checked_impl!(CheckedMul, checked_mul, isize);
+#[cfg(has_i128)]
+checked_impl!(CheckedMul, checked_mul, i128);
+
+/// Performs division that returns `None` instead of panicking on division by zero and instead of
+/// wrapping around on underflow and overflow.
+pub trait CheckedDiv: Sized + Div<Self, Output = Self> {
+    /// Divides two numbers, checking for underflow, overflow and division by
+    /// zero. If any of that happens, `None` is returned.
+    fn checked_div(&self, v: &Self) -> Option<Self>;
+}
+
+checked_impl!(CheckedDiv, checked_div, u8);
+checked_impl!(CheckedDiv, checked_div, u16);
+checked_impl!(CheckedDiv, checked_div, u32);
+checked_impl!(CheckedDiv, checked_div, u64);
+checked_impl!(CheckedDiv, checked_div, usize);
+#[cfg(has_i128)]
+checked_impl!(CheckedDiv, checked_div, u128);
+
+checked_impl!(CheckedDiv, checked_div, i8);
+checked_impl!(CheckedDiv, checked_div, i16);
+checked_impl!(CheckedDiv, checked_div, i32);
+checked_impl!(CheckedDiv, checked_div, i64);
+checked_impl!(CheckedDiv, checked_div, isize);
+#[cfg(has_i128)]
+checked_impl!(CheckedDiv, checked_div, i128);
+
+/// Performs an integral remainder that returns `None` instead of panicking on division by zero and
+/// instead of wrapping around on underflow and overflow.
+pub trait CheckedRem: Sized + Rem<Self, Output = Self> {
+    /// Finds the remainder of dividing two numbers, checking for underflow, overflow and division
+    /// by zero. If any of that happens, `None` is returned.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use num_traits::CheckedRem;
+    /// use std::i32::MIN;
+    ///
+    /// assert_eq!(CheckedRem::checked_rem(&10, &7), Some(3));
+    /// assert_eq!(CheckedRem::checked_rem(&10, &-7), Some(3));
+    /// assert_eq!(CheckedRem::checked_rem(&-10, &7), Some(-3));
+    /// assert_eq!(CheckedRem::checked_rem(&-10, &-7), Some(-3));
+    ///
+    /// assert_eq!(CheckedRem::checked_rem(&10, &0), None);
+    ///
+    /// assert_eq!(CheckedRem::checked_rem(&MIN, &1), Some(0));
+    /// assert_eq!(CheckedRem::checked_rem(&MIN, &-1), None);
+    /// ```
+    fn checked_rem(&self, v: &Self) -> Option<Self>;
+}
+
+checked_impl!(CheckedRem, checked_rem, u8);
+checked_impl!(CheckedRem, checked_rem, u16);
+checked_impl!(CheckedRem, checked_rem, u32);
+checked_impl!(CheckedRem, checked_rem, u64);
+checked_impl!(CheckedRem, checked_rem, usize);
+#[cfg(has_i128)]
+checked_impl!(CheckedRem, checked_rem, u128);
+
+checked_impl!(CheckedRem, checked_rem, i8);
+checked_impl!(CheckedRem, checked_rem, i16);
+checked_impl!(CheckedRem, checked_rem, i32);
+checked_impl!(CheckedRem, checked_rem, i64);
+checked_impl!(CheckedRem, checked_rem, isize);
+#[cfg(has_i128)]
+checked_impl!(CheckedRem, checked_rem, i128);
+
+macro_rules! checked_impl_unary {
+    ($trait_name:ident, $method:ident, $t:ty) => {
+        impl $trait_name for $t {
+            #[inline]
+            fn $method(&self) -> Option<$t> {
+                <$t>::$method(*self)
+            }
+        }
+    };
+}
+
+/// Performs negation that returns `None` if the result can't be represented.
+pub trait CheckedNeg: Sized {
+    /// Negates a number, returning `None` for results that can't be represented, like signed `MIN`
+    /// values that can't be positive, or non-zero unsigned values that can't be negative.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use num_traits::CheckedNeg;
+    /// use std::i32::MIN;
+    ///
+    /// assert_eq!(CheckedNeg::checked_neg(&1_i32), Some(-1));
+    /// assert_eq!(CheckedNeg::checked_neg(&-1_i32), Some(1));
+    /// assert_eq!(CheckedNeg::checked_neg(&MIN), None);
+    ///
+    /// assert_eq!(CheckedNeg::checked_neg(&0_u32), Some(0));
+    /// assert_eq!(CheckedNeg::checked_neg(&1_u32), None);
+    /// ```
+    fn checked_neg(&self) -> Option<Self>;
+}
+
+checked_impl_unary!(CheckedNeg, checked_neg, u8);
+checked_impl_unary!(CheckedNeg, checked_neg, u16);
+checked_impl_unary!(CheckedNeg, checked_neg, u32);
+checked_impl_unary!(CheckedNeg, checked_neg, u64);
+checked_impl_unary!(CheckedNeg, checked_neg, usize);
+#[cfg(has_i128)]
+checked_impl_unary!(CheckedNeg, checked_neg, u128);
+
+checked_impl_unary!(CheckedNeg, checked_neg, i8);
+checked_impl_unary!(CheckedNeg, checked_neg, i16);
+checked_impl_unary!(CheckedNeg, checked_neg, i32);
+checked_impl_unary!(CheckedNeg, checked_neg, i64);
+checked_impl_unary!(CheckedNeg, checked_neg, isize);
+#[cfg(has_i128)]
+checked_impl_unary!(CheckedNeg, checked_neg, i128);
+
+/// Performs a left shift that returns `None` on shifts larger than
+/// the type width.
+pub trait CheckedShl: Sized + Shl<u32, Output = Self> {
+    /// Checked shift left. Computes `self << rhs`, returning `None`
+    /// if `rhs` is larger than or equal to the number of bits in `self`.
+    ///
+    /// ```
+    /// use num_traits::CheckedShl;
+    ///
+    /// let x: u16 = 0x0001;
+    ///
+    /// assert_eq!(CheckedShl::checked_shl(&x, 0),  Some(0x0001));
+    /// assert_eq!(CheckedShl::checked_shl(&x, 1),  Some(0x0002));
+    /// assert_eq!(CheckedShl::checked_shl(&x, 15), Some(0x8000));
+    /// assert_eq!(CheckedShl::checked_shl(&x, 16), None);
+    /// ```
+    fn checked_shl(&self, rhs: u32) -> Option<Self>;
+}
+
+macro_rules! checked_shift_impl {
+    ($trait_name:ident, $method:ident, $t:ty) => {
+        impl $trait_name for $t {
+            #[inline]
+            fn $method(&self, rhs: u32) -> Option<$t> {
+                <$t>::$method(*self, rhs)
+            }
+        }
+    };
+}
+
+checked_shift_impl!(CheckedShl, checked_shl, u8);
+checked_shift_impl!(CheckedShl, checked_shl, u16);
+checked_shift_impl!(CheckedShl, checked_shl, u32);
+checked_shift_impl!(CheckedShl, checked_shl, u64);
+checked_shift_impl!(CheckedShl, checked_shl, usize);
+#[cfg(has_i128)]
+checked_shift_impl!(CheckedShl, checked_shl, u128);
+
+checked_shift_impl!(CheckedShl, checked_shl, i8);
+checked_shift_impl!(CheckedShl, checked_shl, i16);
+checked_shift_impl!(CheckedShl, checked_shl, i32);
+checked_shift_impl!(CheckedShl, checked_shl, i64);
+checked_shift_impl!(CheckedShl, checked_shl, isize);
+#[cfg(has_i128)]
+checked_shift_impl!(CheckedShl, checked_shl, i128);
+
+/// Performs a right shift that returns `None` on shifts larger than
+/// the type width.
+pub trait CheckedShr: Sized + Shr<u32, Output = Self> {
+    /// Checked shift right. Computes `self >> rhs`, returning `None`
+    /// if `rhs` is larger than or equal to the number of bits in `self`.
+    ///
+    /// ```
+    /// use num_traits::CheckedShr;
+    ///
+    /// let x: u16 = 0x8000;
+    ///
+    /// assert_eq!(CheckedShr::checked_shr(&x, 0),  Some(0x8000));
+    /// assert_eq!(CheckedShr::checked_shr(&x, 1),  Some(0x4000));
+    /// assert_eq!(CheckedShr::checked_shr(&x, 15), Some(0x0001));
+    /// assert_eq!(CheckedShr::checked_shr(&x, 16), None);
+    /// ```
+    fn checked_shr(&self, rhs: u32) -> Option<Self>;
+}
+
+checked_shift_impl!(CheckedShr, checked_shr, u8);
+checked_shift_impl!(CheckedShr, checked_shr, u16);
+checked_shift_impl!(CheckedShr, checked_shr, u32);
+checked_shift_impl!(CheckedShr, checked_shr, u64);
+checked_shift_impl!(CheckedShr, checked_shr, usize);
+#[cfg(has_i128)]
+checked_shift_impl!(CheckedShr, checked_shr, u128);
+
+checked_shift_impl!(CheckedShr, checked_shr, i8);
+checked_shift_impl!(CheckedShr, checked_shr, i16);
+checked_shift_impl!(CheckedShr, checked_shr, i32);
+checked_shift_impl!(CheckedShr, checked_shr, i64);
+checked_shift_impl!(CheckedShr, checked_shr, isize);
+#[cfg(has_i128)]
+checked_shift_impl!(CheckedShr, checked_shr, i128);

src/ops/inv.rs

@@ -0,0 +1,47 @@
+/// Unary operator for retrieving the multiplicative inverse, or reciprocal, of a value.
+pub trait Inv {
+    /// The result after applying the operator.
+    type Output;
+
+    /// Returns the multiplicative inverse of `self`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::f64::INFINITY;
+    /// use num_traits::Inv;
+    ///
+    /// assert_eq!(7.0.inv() * 7.0, 1.0);
+    /// assert_eq!((-0.0).inv(), -INFINITY);
+    /// ```
+    fn inv(self) -> Self::Output;
+}
+
+impl Inv for f32 {
+    type Output = f32;
+    #[inline]
+    fn inv(self) -> f32 {
+        1.0 / self
+    }
+}
+impl Inv for f64 {
+    type Output = f64;
+    #[inline]
+    fn inv(self) -> f64 {
+        1.0 / self
+    }
+}
+impl<'a> Inv for &'a f32 {
+    type Output = f32;
+    #[inline]
+    fn inv(self) -> f32 {
+        1.0 / *self
+    }
+}
+impl<'a> Inv for &'a f64 {
+    type Output = f64;
+    #[inline]
+    fn inv(self) -> f64 {
+        1.0 / *self
+    }
+}

src/ops/mod.rs

@@ -0,0 +1,5 @@
+pub mod checked;
+pub mod inv;
+pub mod mul_add;
+pub mod saturating;
+pub mod wrapping;

src/ops/mul_add.rs

@@ -0,0 +1,151 @@
+/// Fused multiply-add. Computes `(self * a) + b` with only one rounding
+/// error, yielding a more accurate result than an unfused multiply-add.
+///
+/// Using `mul_add` can be more performant than an unfused multiply-add if
+/// the target architecture has a dedicated `fma` CPU instruction.
+///
+/// Note that `A` and `B` are `Self` by default, but this is not mandatory.
+///
+/// # Example
+///
+/// ```
+/// use std::f32;
+///
+/// let m = 10.0_f32;
+/// let x = 4.0_f32;
+/// let b = 60.0_f32;
+///
+/// // 100.0
+/// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
+///
+/// assert!(abs_difference <= 100.0 * f32::EPSILON);
+/// ```
+pub trait MulAdd<A = Self, B = Self> {
+    /// The resulting type after applying the fused multiply-add.
+    type Output;
+
+    /// Performs the fused multiply-add operation.
+    fn mul_add(self, a: A, b: B) -> Self::Output;
+}
+
+/// The fused multiply-add assignment operation.
+pub trait MulAddAssign<A = Self, B = Self> {
+    /// Performs the fused multiply-add operation.
+    fn mul_add_assign(&mut self, a: A, b: B);
+}
+
+#[cfg(any(feature = "std", feature = "libm"))]
+impl MulAdd<f32, f32> for f32 {
+    type Output = Self;
+
+    #[inline]
+    fn mul_add(self, a: Self, b: Self) -> Self::Output {
+        <Self as ::Float>::mul_add(self, a, b)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "libm"))]
+impl MulAdd<f64, f64> for f64 {
+    type Output = Self;
+
+    #[inline]
+    fn mul_add(self, a: Self, b: Self) -> Self::Output {
+        <Self as ::Float>::mul_add(self, a, b)
+    }
+}
+
+macro_rules! mul_add_impl {
+    ($trait_name:ident for $($t:ty)*) => {$(
+        impl $trait_name for $t {
+            type Output = Self;
+
+            #[inline]
+            fn mul_add(self, a: Self, b: Self) -> Self::Output {
+                (self * a) + b
+            }
+        }
+    )*}
+}
+
+mul_add_impl!(MulAdd for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
+#[cfg(has_i128)]
+mul_add_impl!(MulAdd for i128 u128);
+
+#[cfg(any(feature = "std", feature = "libm"))]
+impl MulAddAssign<f32, f32> for f32 {
+    #[inline]
+    fn mul_add_assign(&mut self, a: Self, b: Self) {
+        *self = <Self as ::Float>::mul_add(*self, a, b)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "libm"))]
+impl MulAddAssign<f64, f64> for f64 {
+    #[inline]
+    fn mul_add_assign(&mut self, a: Self, b: Self) {
+        *self = <Self as ::Float>::mul_add(*self, a, b)
+    }
+}
+
+macro_rules! mul_add_assign_impl {
+    ($trait_name:ident for $($t:ty)*) => {$(
+        impl $trait_name for $t {
+            #[inline]
+            fn mul_add_assign(&mut self, a: Self, b: Self) {
+                *self = (*self * a) + b
+            }
+        }
+    )*}
+}
+
+mul_add_assign_impl!(MulAddAssign for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
+#[cfg(has_i128)]
+mul_add_assign_impl!(MulAddAssign for i128 u128);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn mul_add_integer() {
+        macro_rules! test_mul_add {
+            ($($t:ident)+) => {
+                $(
+                    {
+                        let m: $t = 2;
+                        let x: $t = 3;
+                        let b: $t = 4;
+
+                        assert_eq!(MulAdd::mul_add(m, x, b), (m*x + b));
+                    }
+                )+
+            };
+        }
+
+        test_mul_add!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+    }
+
+    #[test]
+    #[cfg(feature = "std")]
+    fn mul_add_float() {
+        macro_rules! test_mul_add {
+            ($($t:ident)+) => {
+                $(
+                    {
+                        use core::$t;
+
+                        let m: $t = 12.0;
+                        let x: $t = 3.4;
+                        let b: $t = 5.6;
+
+                        let abs_difference = (MulAdd::mul_add(m, x, b) - (m*x + b)).abs();
+
+                        assert!(abs_difference <= 46.4 * $t::EPSILON);
+                    }
+                )+
+            };
+        }
+
+        test_mul_add!(f32 f64);
+    }
+}

src/ops/saturating.rs

@@ -26,3 +26,5 @@ macro_rules! saturating_impl {
 }
 
 saturating_impl!(Saturating for isize usize i8 u8 i16 u16 i32 u32 i64 u64);
+#[cfg(has_i128)]
+saturating_impl!(Saturating for i128 u128);

src/ops/wrapping.rs

@@ -0,0 +1,272 @@
+use core::num::Wrapping;
+use core::ops::{Add, Mul, Shl, Shr, Sub};
+
+macro_rules! wrapping_impl {
+    ($trait_name:ident, $method:ident, $t:ty) => {
+        impl $trait_name for $t {
+            #[inline]
+            fn $method(&self, v: &Self) -> Self {
+                <$t>::$method(*self, *v)
+            }
+        }
+    };
+    ($trait_name:ident, $method:ident, $t:ty, $rhs:ty) => {
+        impl $trait_name<$rhs> for $t {
+            #[inline]
+            fn $method(&self, v: &$rhs) -> Self {
+                <$t>::$method(*self, *v)
+            }
+        }
+    };
+}
+
+/// Performs addition that wraps around on overflow.
+pub trait WrappingAdd: Sized + Add<Self, Output = Self> {
+    /// Wrapping (modular) addition. Computes `self + other`, wrapping around at the boundary of
+    /// the type.
+    fn wrapping_add(&self, v: &Self) -> Self;
+}
+
+wrapping_impl!(WrappingAdd, wrapping_add, u8);
+wrapping_impl!(WrappingAdd, wrapping_add, u16);
+wrapping_impl!(WrappingAdd, wrapping_add, u32);
+wrapping_impl!(WrappingAdd, wrapping_add, u64);
+wrapping_impl!(WrappingAdd, wrapping_add, usize);
+#[cfg(has_i128)]
+wrapping_impl!(WrappingAdd, wrapping_add, u128);
+
+wrapping_impl!(WrappingAdd, wrapping_add, i8);
+wrapping_impl!(WrappingAdd, wrapping_add, i16);
+wrapping_impl!(WrappingAdd, wrapping_add, i32);
+wrapping_impl!(WrappingAdd, wrapping_add, i64);
+wrapping_impl!(WrappingAdd, wrapping_add, isize);
+#[cfg(has_i128)]
+wrapping_impl!(WrappingAdd, wrapping_add, i128);
+
+/// Performs subtraction that wraps around on overflow.
+pub trait WrappingSub: Sized + Sub<Self, Output = Self> {
+    /// Wrapping (modular) subtraction. Computes `self - other`, wrapping around at the boundary
+    /// of the type.
+    fn wrapping_sub(&self, v: &Self) -> Self;
+}
+
+wrapping_impl!(WrappingSub, wrapping_sub, u8);
+wrapping_impl!(WrappingSub, wrapping_sub, u16);
+wrapping_impl!(WrappingSub, wrapping_sub, u32);
+wrapping_impl!(WrappingSub, wrapping_sub, u64);
+wrapping_impl!(WrappingSub, wrapping_sub, usize);
+#[cfg(has_i128)]
+wrapping_impl!(WrappingSub, wrapping_sub, u128);
+
+wrapping_impl!(WrappingSub, wrapping_sub, i8);
+wrapping_impl!(WrappingSub, wrapping_sub, i16);
+wrapping_impl!(WrappingSub, wrapping_sub, i32);
+wrapping_impl!(WrappingSub, wrapping_sub, i64);
+wrapping_impl!(WrappingSub, wrapping_sub, isize);
+#[cfg(has_i128)]
+wrapping_impl!(WrappingSub, wrapping_sub, i128);
+
+/// Performs multiplication that wraps around on overflow.
+pub trait WrappingMul: Sized + Mul<Self, Output = Self> {
+    /// Wrapping (modular) multiplication. Computes `self * other`, wrapping around at the boundary
+    /// of the type.
+    fn wrapping_mul(&self, v: &Self) -> Self;
+}
+
+wrapping_impl!(WrappingMul, wrapping_mul, u8);
+wrapping_impl!(WrappingMul, wrapping_mul, u16);
+wrapping_impl!(WrappingMul, wrapping_mul, u32);
+wrapping_impl!(WrappingMul, wrapping_mul, u64);
+wrapping_impl!(WrappingMul, wrapping_mul, usize);
+#[cfg(has_i128)]
+wrapping_impl!(WrappingMul, wrapping_mul, u128);
+
+wrapping_impl!(WrappingMul, wrapping_mul, i8);
+wrapping_impl!(WrappingMul, wrapping_mul, i16);
+wrapping_impl!(WrappingMul, wrapping_mul, i32);
+wrapping_impl!(WrappingMul, wrapping_mul, i64);
+wrapping_impl!(WrappingMul, wrapping_mul, isize);
+#[cfg(has_i128)]
+wrapping_impl!(WrappingMul, wrapping_mul, i128);
+
+macro_rules! wrapping_shift_impl {
+    ($trait_name:ident, $method:ident, $t:ty) => {
+        impl $trait_name for $t {
+            #[inline]
+            fn $method(&self, rhs: u32) -> $t {
+                <$t>::$method(*self, rhs)
+            }
+        }
+    };
+}
+
+/// Performs a left shift that does not panic.
+pub trait WrappingShl: Sized + Shl<usize, Output = Self> {
+    /// Panic-free bitwise shift-left; yields `self << mask(rhs)`,
+    /// where `mask` removes any high order bits of `rhs` that would
+    /// cause the shift to exceed the bitwidth of the type.
+    ///
+    /// ```
+    /// use num_traits::WrappingShl;
+    ///
+    /// let x: u16 = 0x0001;
+    ///
+    /// assert_eq!(WrappingShl::wrapping_shl(&x, 0),  0x0001);
+    /// assert_eq!(WrappingShl::wrapping_shl(&x, 1),  0x0002);
+    /// assert_eq!(WrappingShl::wrapping_shl(&x, 15), 0x8000);
+    /// assert_eq!(WrappingShl::wrapping_shl(&x, 16), 0x0001);
+    /// ```
+    fn wrapping_shl(&self, rhs: u32) -> Self;
+}
+
+wrapping_shift_impl!(WrappingShl, wrapping_shl, u8);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, u16);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, u32);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, u64);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, usize);
+#[cfg(has_i128)]
+wrapping_shift_impl!(WrappingShl, wrapping_shl, u128);
+
+wrapping_shift_impl!(WrappingShl, wrapping_shl, i8);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, i16);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, i32);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, i64);
+wrapping_shift_impl!(WrappingShl, wrapping_shl, isize);
+#[cfg(has_i128)]
+wrapping_shift_impl!(WrappingShl, wrapping_shl, i128);
+
+/// Performs a right shift that does not panic.
+pub trait WrappingShr: Sized + Shr<usize, Output = Self> {
+    /// Panic-free bitwise shift-right; yields `self >> mask(rhs)`,
+    /// where `mask` removes any high order bits of `rhs` that would
+    /// cause the shift to exceed the bitwidth of the type.
+    ///
+    /// ```
+    /// use num_traits::WrappingShr;
+    ///
+    /// let x: u16 = 0x8000;
+    ///
+    /// assert_eq!(WrappingShr::wrapping_shr(&x, 0),  0x8000);
+    /// assert_eq!(WrappingShr::wrapping_shr(&x, 1),  0x4000);
+    /// assert_eq!(WrappingShr::wrapping_shr(&x, 15), 0x0001);
+    /// assert_eq!(WrappingShr::wrapping_shr(&x, 16), 0x8000);
+    /// ```
+    fn wrapping_shr(&self, rhs: u32) -> Self;
+}
+
+wrapping_shift_impl!(WrappingShr, wrapping_shr, u8);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, u16);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, u32);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, u64);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, usize);
+#[cfg(has_i128)]
+wrapping_shift_impl!(WrappingShr, wrapping_shr, u128);
+
+wrapping_shift_impl!(WrappingShr, wrapping_shr, i8);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, i16);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, i32);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, i64);
+wrapping_shift_impl!(WrappingShr, wrapping_shr, isize);
+#[cfg(has_i128)]
+wrapping_shift_impl!(WrappingShr, wrapping_shr, i128);
+
+// Well this is a bit funny, but all the more appropriate.
+impl<T: WrappingAdd> WrappingAdd for Wrapping<T>
+where
+    Wrapping<T>: Add<Output = Wrapping<T>>,
+{
+    fn wrapping_add(&self, v: &Self) -> Self {
+        Wrapping(self.0.wrapping_add(&v.0))
+    }
+}
+impl<T: WrappingSub> WrappingSub for Wrapping<T>
+where
+    Wrapping<T>: Sub<Output = Wrapping<T>>,
+{
+    fn wrapping_sub(&self, v: &Self) -> Self {
+        Wrapping(self.0.wrapping_sub(&v.0))
+    }
+}
+impl<T: WrappingMul> WrappingMul for Wrapping<T>
+where
+    Wrapping<T>: Mul<Output = Wrapping<T>>,
+{
+    fn wrapping_mul(&self, v: &Self) -> Self {
+        Wrapping(self.0.wrapping_mul(&v.0))
+    }
+}
+impl<T: WrappingShl> WrappingShl for Wrapping<T>
+where
+    Wrapping<T>: Shl<usize, Output = Wrapping<T>>,
+{
+    fn wrapping_shl(&self, rhs: u32) -> Self {
+        Wrapping(self.0.wrapping_shl(rhs))
+    }
+}
+impl<T: WrappingShr> WrappingShr for Wrapping<T>
+where
+    Wrapping<T>: Shr<usize, Output = Wrapping<T>>,
+{
+    fn wrapping_shr(&self, rhs: u32) -> Self {
+        Wrapping(self.0.wrapping_shr(rhs))
+    }
+}
+
+#[test]
+fn test_wrapping_traits() {
+    fn wrapping_add<T: WrappingAdd>(a: T, b: T) -> T {
+        a.wrapping_add(&b)
+    }
+    fn wrapping_sub<T: WrappingSub>(a: T, b: T) -> T {
+        a.wrapping_sub(&b)
+    }
+    fn wrapping_mul<T: WrappingMul>(a: T, b: T) -> T {
+        a.wrapping_mul(&b)
+    }
+    fn wrapping_shl<T: WrappingShl>(a: T, b: u32) -> T {
+        a.wrapping_shl(b)
+    }
+    fn wrapping_shr<T: WrappingShr>(a: T, b: u32) -> T {
+        a.wrapping_shr(b)
+    }
+    assert_eq!(wrapping_add(255, 1), 0u8);
+    assert_eq!(wrapping_sub(0, 1), 255u8);
+    assert_eq!(wrapping_mul(255, 2), 254u8);
+    assert_eq!(wrapping_shl(255, 8), 255u8);
+    assert_eq!(wrapping_shr(255, 8), 255u8);
+    assert_eq!(wrapping_add(255, 1), (Wrapping(255u8) + Wrapping(1u8)).0);
+    assert_eq!(wrapping_sub(0, 1), (Wrapping(0u8) - Wrapping(1u8)).0);
+    assert_eq!(wrapping_mul(255, 2), (Wrapping(255u8) * Wrapping(2u8)).0);
+    assert_eq!(wrapping_shl(255, 8), (Wrapping(255u8) << 8).0);
+    assert_eq!(wrapping_shr(255, 8), (Wrapping(255u8) >> 8).0);
+}
+
+#[test]
+fn wrapping_is_wrappingadd() {
+    fn require_wrappingadd<T: WrappingAdd>(_: &T) {}
+    require_wrappingadd(&Wrapping(42));
+}
+
+#[test]
+fn wrapping_is_wrappingsub() {
+    fn require_wrappingsub<T: WrappingSub>(_: &T) {}
+    require_wrappingsub(&Wrapping(42));
+}
+
+#[test]
+fn wrapping_is_wrappingmul() {
+    fn require_wrappingmul<T: WrappingMul>(_: &T) {}
+    require_wrappingmul(&Wrapping(42));
+}
+
+#[test]
+fn wrapping_is_wrappingshl() {
+    fn require_wrappingshl<T: WrappingShl>(_: &T) {}
+    require_wrappingshl(&Wrapping(42));
+}
+
+#[test]
+fn wrapping_is_wrappingshr() {
+    fn require_wrappingshr<T: WrappingShr>(_: &T) {}
+    require_wrappingshr(&Wrapping(42));
+}

src/pow.rs

@@ -0,0 +1,262 @@
+use core::num::Wrapping;
+use core::ops::Mul;
+use {CheckedMul, One};
+
+/// Binary operator for raising a value to a power.
+pub trait Pow<RHS> {
+    /// The result after applying the operator.
+    type Output;
+
+    /// Returns `self` to the power `rhs`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use num_traits::Pow;
+    /// assert_eq!(Pow::pow(10u32, 2u32), 100);
+    /// ```
+    fn pow(self, rhs: RHS) -> Self::Output;
+}
+
+macro_rules! pow_impl {
+    ($t:ty) => {
+        pow_impl!($t, u8);
+        pow_impl!($t, usize);
+
+        // FIXME: these should be possible
+        // pow_impl!($t, u16);
+        // pow_impl!($t, u32);
+        // pow_impl!($t, u64);
+    };
+    ($t:ty, $rhs:ty) => {
+        pow_impl!($t, $rhs, usize, pow);
+    };
+    ($t:ty, $rhs:ty, $desired_rhs:ty, $method:expr) => {
+        impl Pow<$rhs> for $t {
+            type Output = $t;
+            #[inline]
+            fn pow(self, rhs: $rhs) -> $t {
+                ($method)(self, <$desired_rhs>::from(rhs))
+            }
+        }
+
+        impl<'a> Pow<&'a $rhs> for $t {
+            type Output = $t;
+            #[inline]
+            fn pow(self, rhs: &'a $rhs) -> $t {
+                ($method)(self, <$desired_rhs>::from(*rhs))
+            }
+        }
+
+        impl<'a> Pow<$rhs> for &'a $t {
+            type Output = $t;
+            #[inline]
+            fn pow(self, rhs: $rhs) -> $t {
+                ($method)(*self, <$desired_rhs>::from(rhs))
+            }
+        }
+
+        impl<'a, 'b> Pow<&'a $rhs> for &'b $t {
+            type Output = $t;
+            #[inline]
+            fn pow(self, rhs: &'a $rhs) -> $t {
+                ($method)(*self, <$desired_rhs>::from(*rhs))
+            }
+        }
+    };
+}
+
+pow_impl!(u8, u8, u32, u8::pow);
+pow_impl!(u8, u16, u32, u8::pow);
+pow_impl!(u8, u32, u32, u8::pow);
+pow_impl!(u8, usize);
+pow_impl!(i8, u8, u32, i8::pow);
+pow_impl!(i8, u16, u32, i8::pow);
+pow_impl!(i8, u32, u32, i8::pow);
+pow_impl!(i8, usize);
+pow_impl!(u16, u8, u32, u16::pow);
+pow_impl!(u16, u16, u32, u16::pow);
+pow_impl!(u16, u32, u32, u16::pow);
+pow_impl!(u16, usize);
+pow_impl!(i16, u8, u32, i16::pow);
+pow_impl!(i16, u16, u32, i16::pow);
+pow_impl!(i16, u32, u32, i16::pow);
+pow_impl!(i16, usize);
+pow_impl!(u32, u8, u32, u32::pow);
+pow_impl!(u32, u16, u32, u32::pow);
+pow_impl!(u32, u32, u32, u32::pow);
+pow_impl!(u32, usize);
+pow_impl!(i32, u8, u32, i32::pow);
+pow_impl!(i32, u16, u32, i32::pow);
+pow_impl!(i32, u32, u32, i32::pow);
+pow_impl!(i32, usize);
+pow_impl!(u64, u8, u32, u64::pow);
+pow_impl!(u64, u16, u32, u64::pow);
+pow_impl!(u64, u32, u32, u64::pow);
+pow_impl!(u64, usize);
+pow_impl!(i64, u8, u32, i64::pow);
+pow_impl!(i64, u16, u32, i64::pow);
+pow_impl!(i64, u32, u32, i64::pow);
+pow_impl!(i64, usize);
+
+#[cfg(has_i128)]
+pow_impl!(u128, u8, u32, u128::pow);
+#[cfg(has_i128)]
+pow_impl!(u128, u16, u32, u128::pow);
+#[cfg(has_i128)]
+pow_impl!(u128, u32, u32, u128::pow);
+#[cfg(has_i128)]
+pow_impl!(u128, usize);
+
+#[cfg(has_i128)]
+pow_impl!(i128, u8, u32, i128::pow);
+#[cfg(has_i128)]
+pow_impl!(i128, u16, u32, i128::pow);
+#[cfg(has_i128)]
+pow_impl!(i128, u32, u32, i128::pow);
+#[cfg(has_i128)]
+pow_impl!(i128, usize);
+
+pow_impl!(usize, u8, u32, usize::pow);
+pow_impl!(usize, u16, u32, usize::pow);
+pow_impl!(usize, u32, u32, usize::pow);
+pow_impl!(usize, usize);
+pow_impl!(isize, u8, u32, isize::pow);
+pow_impl!(isize, u16, u32, isize::pow);
+pow_impl!(isize, u32, u32, isize::pow);
+pow_impl!(isize, usize);
+pow_impl!(Wrapping<u8>);
+pow_impl!(Wrapping<i8>);
+pow_impl!(Wrapping<u16>);
+pow_impl!(Wrapping<i16>);
+pow_impl!(Wrapping<u32>);
+pow_impl!(Wrapping<i32>);
+pow_impl!(Wrapping<u64>);
+pow_impl!(Wrapping<i64>);
+#[cfg(has_i128)]
+pow_impl!(Wrapping<u128>);
+#[cfg(has_i128)]
+pow_impl!(Wrapping<i128>);
+pow_impl!(Wrapping<usize>);
+pow_impl!(Wrapping<isize>);
+
+// FIXME: these should be possible
+// pow_impl!(u8, u64);
+// pow_impl!(i16, u64);
+// pow_impl!(i8, u64);
+// pow_impl!(u16, u64);
+// pow_impl!(u32, u64);
+// pow_impl!(i32, u64);
+// pow_impl!(u64, u64);
+// pow_impl!(i64, u64);
+// pow_impl!(usize, u64);
+// pow_impl!(isize, u64);
+
+#[cfg(any(feature = "std", feature = "libm"))]
+mod float_impls {
+    use super::Pow;
+    use Float;
+
+    pow_impl!(f32, i8, i32, <f32 as Float>::powi);
+    pow_impl!(f32, u8, i32, <f32 as Float>::powi);
+    pow_impl!(f32, i16, i32, <f32 as Float>::powi);
+    pow_impl!(f32, u16, i32, <f32 as Float>::powi);
+    pow_impl!(f32, i32, i32, <f32 as Float>::powi);
+    pow_impl!(f64, i8, i32, <f64 as Float>::powi);
+    pow_impl!(f64, u8, i32, <f64 as Float>::powi);
+    pow_impl!(f64, i16, i32, <f64 as Float>::powi);
+    pow_impl!(f64, u16, i32, <f64 as Float>::powi);
+    pow_impl!(f64, i32, i32, <f64 as Float>::powi);
+    pow_impl!(f32, f32, f32, <f32 as Float>::powf);
+    pow_impl!(f64, f32, f64, <f64 as Float>::powf);
+    pow_impl!(f64, f64, f64, <f64 as Float>::powf);
+}
+
+/// Raises a value to the power of exp, using exponentiation by squaring.
+///
+/// Note that `0⁰` (`pow(0, 0)`) returns `1`. Mathematically this is undefined.
+///
+/// # Example
+///
+/// ```rust
+/// use num_traits::pow;
+///
+/// assert_eq!(pow(2i8, 4), 16);
+/// assert_eq!(pow(6u8, 3), 216);
+/// assert_eq!(pow(0u8, 0), 1); // Be aware if this case affects you
+/// ```
+#[inline]
+pub fn pow<T: Clone + One + Mul<T, Output = T>>(mut base: T, mut exp: usize) -> T {
+    if exp == 0 {
+        return T::one();
+    }
+
+    while exp & 1 == 0 {
+        base = base.clone() * base;
+        exp >>= 1;
+    }
+    if exp == 1 {
+        return base;
+    }
+
+    let mut acc = base.clone();
+    while exp > 1 {
+        exp >>= 1;
+        base = base.clone() * base;
+        if exp & 1 == 1 {
+            acc = acc * base.clone();
+        }
+    }
+    acc
+}
+
+/// Raises a value to the power of exp, returning `None` if an overflow occurred.
+///
+/// Note that `0⁰` (`checked_pow(0, 0)`) returns `Some(1)`. Mathematically this is undefined.
+///
+/// Otherwise same as the `pow` function.
+///
+/// # Example
+///
+/// ```rust
+/// use num_traits::checked_pow;
+///
+/// assert_eq!(checked_pow(2i8, 4), Some(16));
+/// assert_eq!(checked_pow(7i8, 8), None);
+/// assert_eq!(checked_pow(7u32, 8), Some(5_764_801));
+/// assert_eq!(checked_pow(0u32, 0), Some(1)); // Be aware if this case affect you
+/// ```
+#[inline]
+pub fn checked_pow<T: Clone + One + CheckedMul>(mut base: T, mut exp: usize) -> Option<T> {
+    if exp == 0 {
+        return Some(T::one());
+    }
+
+    macro_rules! optry {
+        ($expr:expr) => {
+            if let Some(val) = $expr {
+                val
+            } else {
+                return None;
+            }
+        };
+    }
+
+    while exp & 1 == 0 {
+        base = optry!(base.checked_mul(&base));
+        exp >>= 1;
+    }
+    if exp == 1 {
+        return Some(base);
+    }
+
+    let mut acc = base.clone();
+    while exp > 1 {
+        exp >>= 1;
+        base = optry!(base.checked_mul(&base));
+        if exp & 1 == 1 {
+            acc = optry!(acc.checked_mul(&base));
+        }
+    }
+    Some(acc)
+}

src/real.rs

@@ -0,0 +1,834 @@
+#![cfg(any(feature = "std", feature = "libm"))]
+
+use core::ops::Neg;
+
+use {Float, Num, NumCast};
+
+// NOTE: These doctests have the same issue as those in src/float.rs.
+// They're testing the inherent methods directly, and not those of `Real`.
+
+/// A trait for real number types that do not necessarily have
+/// floating-point-specific characteristics such as NaN and infinity.
+///
+/// See [this Wikipedia article](https://en.wikipedia.org/wiki/Real_data_type)
+/// for a list of data types that could meaningfully implement this trait.
+///
+/// This trait is only available with the `std` feature, or with the `libm` feature otherwise.
+pub trait Real: Num + Copy + NumCast + PartialOrd + Neg<Output = Self> {
+    /// Returns the smallest finite value that this type can represent.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x: f64 = Real::min_value();
+    ///
+    /// assert_eq!(x, f64::MIN);
+    /// ```
+    fn min_value() -> Self;
+
+    /// Returns the smallest positive, normalized value that this type can represent.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x: f64 = Real::min_positive_value();
+    ///
+    /// assert_eq!(x, f64::MIN_POSITIVE);
+    /// ```
+    fn min_positive_value() -> Self;
+
+    /// Returns epsilon, a small positive value.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x: f64 = Real::epsilon();
+    ///
+    /// assert_eq!(x, f64::EPSILON);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// The default implementation will panic if `f32::EPSILON` cannot
+    /// be cast to `Self`.
+    fn epsilon() -> Self;
+
+    /// Returns the largest finite value that this type can represent.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x: f64 = Real::max_value();
+    /// assert_eq!(x, f64::MAX);
+    /// ```
+    fn max_value() -> Self;
+
+    /// Returns the largest integer less than or equal to a number.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let f = 3.99;
+    /// let g = 3.0;
+    ///
+    /// assert_eq!(f.floor(), 3.0);
+    /// assert_eq!(g.floor(), 3.0);
+    /// ```
+    fn floor(self) -> Self;
+
+    /// Returns the smallest integer greater than or equal to a number.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let f = 3.01;
+    /// let g = 4.0;
+    ///
+    /// assert_eq!(f.ceil(), 4.0);
+    /// assert_eq!(g.ceil(), 4.0);
+    /// ```
+    fn ceil(self) -> Self;
+
+    /// Returns the nearest integer to a number. Round half-way cases away from
+    /// `0.0`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let f = 3.3;
+    /// let g = -3.3;
+    ///
+    /// assert_eq!(f.round(), 3.0);
+    /// assert_eq!(g.round(), -3.0);
+    /// ```
+    fn round(self) -> Self;
+
+    /// Return the integer part of a number.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let f = 3.3;
+    /// let g = -3.7;
+    ///
+    /// assert_eq!(f.trunc(), 3.0);
+    /// assert_eq!(g.trunc(), -3.0);
+    /// ```
+    fn trunc(self) -> Self;
+
+    /// Returns the fractional part of a number.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 3.5;
+    /// let y = -3.5;
+    /// let abs_difference_x = (x.fract() - 0.5).abs();
+    /// let abs_difference_y = (y.fract() - (-0.5)).abs();
+    ///
+    /// assert!(abs_difference_x < 1e-10);
+    /// assert!(abs_difference_y < 1e-10);
+    /// ```
+    fn fract(self) -> Self;
+
+    /// Computes the absolute value of `self`. Returns `Float::nan()` if the
+    /// number is `Float::nan()`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x = 3.5;
+    /// let y = -3.5;
+    ///
+    /// let abs_difference_x = (x.abs() - x).abs();
+    /// let abs_difference_y = (y.abs() - (-y)).abs();
+    ///
+    /// assert!(abs_difference_x < 1e-10);
+    /// assert!(abs_difference_y < 1e-10);
+    ///
+    /// assert!(::num_traits::Float::is_nan(f64::NAN.abs()));
+    /// ```
+    fn abs(self) -> Self;
+
+    /// Returns a number that represents the sign of `self`.
+    ///
+    /// - `1.0` if the number is positive, `+0.0` or `Float::infinity()`
+    /// - `-1.0` if the number is negative, `-0.0` or `Float::neg_infinity()`
+    /// - `Float::nan()` if the number is `Float::nan()`
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let f = 3.5;
+    ///
+    /// assert_eq!(f.signum(), 1.0);
+    /// assert_eq!(f64::NEG_INFINITY.signum(), -1.0);
+    ///
+    /// assert!(f64::NAN.signum().is_nan());
+    /// ```
+    fn signum(self) -> Self;
+
+    /// Returns `true` if `self` is positive, including `+0.0`,
+    /// `Float::infinity()`, and with newer versions of Rust `f64::NAN`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let neg_nan: f64 = -f64::NAN;
+    ///
+    /// let f = 7.0;
+    /// let g = -7.0;
+    ///
+    /// assert!(f.is_sign_positive());
+    /// assert!(!g.is_sign_positive());
+    /// assert!(!neg_nan.is_sign_positive());
+    /// ```
+    fn is_sign_positive(self) -> bool;
+
+    /// Returns `true` if `self` is negative, including `-0.0`,
+    /// `Float::neg_infinity()`, and with newer versions of Rust `-f64::NAN`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let nan: f64 = f64::NAN;
+    ///
+    /// let f = 7.0;
+    /// let g = -7.0;
+    ///
+    /// assert!(!f.is_sign_negative());
+    /// assert!(g.is_sign_negative());
+    /// assert!(!nan.is_sign_negative());
+    /// ```
+    fn is_sign_negative(self) -> bool;
+
+    /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
+    /// error, yielding a more accurate result than an unfused multiply-add.
+    ///
+    /// Using `mul_add` can be more performant than an unfused multiply-add if
+    /// the target architecture has a dedicated `fma` CPU instruction.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let m = 10.0;
+    /// let x = 4.0;
+    /// let b = 60.0;
+    ///
+    /// // 100.0
+    /// let abs_difference = (m.mul_add(x, b) - (m*x + b)).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn mul_add(self, a: Self, b: Self) -> Self;
+
+    /// Take the reciprocal (inverse) of a number, `1/x`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 2.0;
+    /// let abs_difference = (x.recip() - (1.0/x)).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn recip(self) -> Self;
+
+    /// Raise a number to an integer power.
+    ///
+    /// Using this function is generally faster than using `powf`
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 2.0;
+    /// let abs_difference = (x.powi(2) - x*x).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn powi(self, n: i32) -> Self;
+
+    /// Raise a number to a real number power.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 2.0;
+    /// let abs_difference = (x.powf(2.0) - x*x).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn powf(self, n: Self) -> Self;
+
+    /// Take the square root of a number.
+    ///
+    /// Returns NaN if `self` is a negative floating-point number.  
+    ///
+    /// # Panics
+    ///
+    /// If the implementing type doesn't support NaN, this method should panic if `self < 0`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let positive = 4.0;
+    /// let negative = -4.0;
+    ///
+    /// let abs_difference = (positive.sqrt() - 2.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// assert!(::num_traits::Float::is_nan(negative.sqrt()));
+    /// ```
+    fn sqrt(self) -> Self;
+
+    /// Returns `e^(self)`, (the exponential function).
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let one = 1.0;
+    /// // e^1
+    /// let e = one.exp();
+    ///
+    /// // ln(e) - 1 == 0
+    /// let abs_difference = (e.ln() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn exp(self) -> Self;
+
+    /// Returns `2^(self)`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let f = 2.0;
+    ///
+    /// // 2^2 - 4 == 0
+    /// let abs_difference = (f.exp2() - 4.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn exp2(self) -> Self;
+
+    /// Returns the natural logarithm of the number.
+    ///
+    /// # Panics
+    ///
+    /// If `self <= 0` and this type does not support a NaN representation, this function should panic.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let one = 1.0;
+    /// // e^1
+    /// let e = one.exp();
+    ///
+    /// // ln(e) - 1 == 0
+    /// let abs_difference = (e.ln() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn ln(self) -> Self;
+
+    /// Returns the logarithm of the number with respect to an arbitrary base.
+    ///
+    /// # Panics
+    ///
+    /// If `self <= 0` and this type does not support a NaN representation, this function should panic.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let ten = 10.0;
+    /// let two = 2.0;
+    ///
+    /// // log10(10) - 1 == 0
+    /// let abs_difference_10 = (ten.log(10.0) - 1.0).abs();
+    ///
+    /// // log2(2) - 1 == 0
+    /// let abs_difference_2 = (two.log(2.0) - 1.0).abs();
+    ///
+    /// assert!(abs_difference_10 < 1e-10);
+    /// assert!(abs_difference_2 < 1e-10);
+    /// ```
+    fn log(self, base: Self) -> Self;
+
+    /// Returns the base 2 logarithm of the number.
+    ///
+    /// # Panics
+    ///
+    /// If `self <= 0` and this type does not support a NaN representation, this function should panic.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let two = 2.0;
+    ///
+    /// // log2(2) - 1 == 0
+    /// let abs_difference = (two.log2() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn log2(self) -> Self;
+
+    /// Returns the base 10 logarithm of the number.
+    ///
+    /// # Panics
+    ///
+    /// If `self <= 0` and this type does not support a NaN representation, this function should panic.
+    ///
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let ten = 10.0;
+    ///
+    /// // log10(10) - 1 == 0
+    /// let abs_difference = (ten.log10() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn log10(self) -> Self;
+
+    /// Converts radians to degrees.
+    ///
+    /// ```
+    /// use std::f64::consts;
+    ///
+    /// let angle = consts::PI;
+    ///
+    /// let abs_difference = (angle.to_degrees() - 180.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn to_degrees(self) -> Self;
+
+    /// Converts degrees to radians.
+    ///
+    /// ```
+    /// use std::f64::consts;
+    ///
+    /// let angle = 180.0_f64;
+    ///
+    /// let abs_difference = (angle.to_radians() - consts::PI).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn to_radians(self) -> Self;
+
+    /// Returns the maximum of the two numbers.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 1.0;
+    /// let y = 2.0;
+    ///
+    /// assert_eq!(x.max(y), y);
+    /// ```
+    fn max(self, other: Self) -> Self;
+
+    /// Returns the minimum of the two numbers.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 1.0;
+    /// let y = 2.0;
+    ///
+    /// assert_eq!(x.min(y), x);
+    /// ```
+    fn min(self, other: Self) -> Self;
+
+    /// The positive difference of two numbers.
+    ///
+    /// * If `self <= other`: `0:0`
+    /// * Else: `self - other`
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 3.0;
+    /// let y = -3.0;
+    ///
+    /// let abs_difference_x = (x.abs_sub(1.0) - 2.0).abs();
+    /// let abs_difference_y = (y.abs_sub(1.0) - 0.0).abs();
+    ///
+    /// assert!(abs_difference_x < 1e-10);
+    /// assert!(abs_difference_y < 1e-10);
+    /// ```
+    fn abs_sub(self, other: Self) -> Self;
+
+    /// Take the cubic root of a number.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 8.0;
+    ///
+    /// // x^(1/3) - 2 == 0
+    /// let abs_difference = (x.cbrt() - 2.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn cbrt(self) -> Self;
+
+    /// Calculate the length of the hypotenuse of a right-angle triangle given
+    /// legs of length `x` and `y`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 2.0;
+    /// let y = 3.0;
+    ///
+    /// // sqrt(x^2 + y^2)
+    /// let abs_difference = (x.hypot(y) - (x.powi(2) + y.powi(2)).sqrt()).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn hypot(self, other: Self) -> Self;
+
+    /// Computes the sine of a number (in radians).
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x = f64::consts::PI/2.0;
+    ///
+    /// let abs_difference = (x.sin() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn sin(self) -> Self;
+
+    /// Computes the cosine of a number (in radians).
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x = 2.0*f64::consts::PI;
+    ///
+    /// let abs_difference = (x.cos() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn cos(self) -> Self;
+
+    /// Computes the tangent of a number (in radians).
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x = f64::consts::PI/4.0;
+    /// let abs_difference = (x.tan() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-14);
+    /// ```
+    fn tan(self) -> Self;
+
+    /// Computes the arcsine of a number. Return value is in radians in
+    /// the range [-pi/2, pi/2] or NaN if the number is outside the range
+    /// [-1, 1].
+    ///
+    /// # Panics
+    ///
+    /// If this type does not support a NaN representation, this function should panic
+    /// if the number is outside the range [-1, 1].
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let f = f64::consts::PI / 2.0;
+    ///
+    /// // asin(sin(pi/2))
+    /// let abs_difference = (f.sin().asin() - f64::consts::PI / 2.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn asin(self) -> Self;
+
+    /// Computes the arccosine of a number. Return value is in radians in
+    /// the range [0, pi] or NaN if the number is outside the range
+    /// [-1, 1].
+    ///
+    /// # Panics
+    ///
+    /// If this type does not support a NaN representation, this function should panic
+    /// if the number is outside the range [-1, 1].
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let f = f64::consts::PI / 4.0;
+    ///
+    /// // acos(cos(pi/4))
+    /// let abs_difference = (f.cos().acos() - f64::consts::PI / 4.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn acos(self) -> Self;
+
+    /// Computes the arctangent of a number. Return value is in radians in the
+    /// range [-pi/2, pi/2];
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let f = 1.0;
+    ///
+    /// // atan(tan(1))
+    /// let abs_difference = (f.tan().atan() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn atan(self) -> Self;
+
+    /// Computes the four quadrant arctangent of `self` (`y`) and `other` (`x`).
+    ///
+    /// * `x = 0`, `y = 0`: `0`
+    /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
+    /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
+    /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let pi = f64::consts::PI;
+    /// // All angles from horizontal right (+x)
+    /// // 45 deg counter-clockwise
+    /// let x1 = 3.0;
+    /// let y1 = -3.0;
+    ///
+    /// // 135 deg clockwise
+    /// let x2 = -3.0;
+    /// let y2 = 3.0;
+    ///
+    /// let abs_difference_1 = (y1.atan2(x1) - (-pi/4.0)).abs();
+    /// let abs_difference_2 = (y2.atan2(x2) - 3.0*pi/4.0).abs();
+    ///
+    /// assert!(abs_difference_1 < 1e-10);
+    /// assert!(abs_difference_2 < 1e-10);
+    /// ```
+    fn atan2(self, other: Self) -> Self;
+
+    /// Simultaneously computes the sine and cosine of the number, `x`. Returns
+    /// `(sin(x), cos(x))`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x = f64::consts::PI/4.0;
+    /// let f = x.sin_cos();
+    ///
+    /// let abs_difference_0 = (f.0 - x.sin()).abs();
+    /// let abs_difference_1 = (f.1 - x.cos()).abs();
+    ///
+    /// assert!(abs_difference_0 < 1e-10);
+    /// assert!(abs_difference_0 < 1e-10);
+    /// ```
+    fn sin_cos(self) -> (Self, Self);
+
+    /// Returns `e^(self) - 1` in a way that is accurate even if the
+    /// number is close to zero.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 7.0;
+    ///
+    /// // e^(ln(7)) - 1
+    /// let abs_difference = (x.ln().exp_m1() - 6.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn exp_m1(self) -> Self;
+
+    /// Returns `ln(1+n)` (natural logarithm) more accurately than if
+    /// the operations were performed separately.
+    ///
+    /// # Panics
+    ///
+    /// If this type does not support a NaN representation, this function should panic
+    /// if `self-1 <= 0`.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let x = f64::consts::E - 1.0;
+    ///
+    /// // ln(1 + (e - 1)) == ln(e) == 1
+    /// let abs_difference = (x.ln_1p() - 1.0).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn ln_1p(self) -> Self;
+
+    /// Hyperbolic sine function.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let e = f64::consts::E;
+    /// let x = 1.0;
+    ///
+    /// let f = x.sinh();
+    /// // Solving sinh() at 1 gives `(e^2-1)/(2e)`
+    /// let g = (e*e - 1.0)/(2.0*e);
+    /// let abs_difference = (f - g).abs();
+    ///
+    /// assert!(abs_difference < 1e-10);
+    /// ```
+    fn sinh(self) -> Self;
+
+    /// Hyperbolic cosine function.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let e = f64::consts::E;
+    /// let x = 1.0;
+    /// let f = x.cosh();
+    /// // Solving cosh() at 1 gives this result
+    /// let g = (e*e + 1.0)/(2.0*e);
+    /// let abs_difference = (f - g).abs();
+    ///
+    /// // Same result
+    /// assert!(abs_difference < 1.0e-10);
+    /// ```
+    fn cosh(self) -> Self;
+
+    /// Hyperbolic tangent function.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let e = f64::consts::E;
+    /// let x = 1.0;
+    ///
+    /// let f = x.tanh();
+    /// // Solving tanh() at 1 gives `(1 - e^(-2))/(1 + e^(-2))`
+    /// let g = (1.0 - e.powi(-2))/(1.0 + e.powi(-2));
+    /// let abs_difference = (f - g).abs();
+    ///
+    /// assert!(abs_difference < 1.0e-10);
+    /// ```
+    fn tanh(self) -> Self;
+
+    /// Inverse hyperbolic sine function.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 1.0;
+    /// let f = x.sinh().asinh();
+    ///
+    /// let abs_difference = (f - x).abs();
+    ///
+    /// assert!(abs_difference < 1.0e-10);
+    /// ```
+    fn asinh(self) -> Self;
+
+    /// Inverse hyperbolic cosine function.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    ///
+    /// let x = 1.0;
+    /// let f = x.cosh().acosh();
+    ///
+    /// let abs_difference = (f - x).abs();
+    ///
+    /// assert!(abs_difference < 1.0e-10);
+    /// ```
+    fn acosh(self) -> Self;
+
+    /// Inverse hyperbolic tangent function.
+    ///
+    /// ```
+    /// use num_traits::real::Real;
+    /// use std::f64;
+    ///
+    /// let e = f64::consts::E;
+    /// let f = e.tanh().atanh();
+    ///
+    /// let abs_difference = (f - e).abs();
+    ///
+    /// assert!(abs_difference < 1.0e-10);
+    /// ```
+    fn atanh(self) -> Self;
+}
+
+impl<T: Float> Real for T {
+    forward! {
+        Float::min_value() -> Self;
+        Float::min_positive_value() -> Self;
+        Float::epsilon() -> Self;
+        Float::max_value() -> Self;
+    }
+    forward! {
+        Float::floor(self) -> Self;
+        Float::ceil(self) -> Self;
+        Float::round(self) -> Self;
+        Float::trunc(self) -> Self;
+        Float::fract(self) -> Self;
+        Float::abs(self) -> Self;
+        Float::signum(self) -> Self;
+        Float::is_sign_positive(self) -> bool;
+        Float::is_sign_negative(self) -> bool;
+        Float::mul_add(self, a: Self, b: Self) -> Self;
+        Float::recip(self) -> Self;
+        Float::powi(self, n: i32) -> Self;
+        Float::powf(self, n: Self) -> Self;
+        Float::sqrt(self) -> Self;
+        Float::exp(self) -> Self;
+        Float::exp2(self) -> Self;
+        Float::ln(self) -> Self;
+        Float::log(self, base: Self) -> Self;
+        Float::log2(self) -> Self;
+        Float::log10(self) -> Self;
+        Float::to_degrees(self) -> Self;
+        Float::to_radians(self) -> Self;
+        Float::max(self, other: Self) -> Self;
+        Float::min(self, other: Self) -> Self;
+        Float::abs_sub(self, other: Self) -> Self;
+        Float::cbrt(self) -> Self;
+        Float::hypot(self, other: Self) -> Self;
+        Float::sin(self) -> Self;
+        Float::cos(self) -> Self;
+        Float::tan(self) -> Self;
+        Float::asin(self) -> Self;
+        Float::acos(self) -> Self;
+        Float::atan(self) -> Self;
+        Float::atan2(self, other: Self) -> Self;
+        Float::sin_cos(self) -> (Self, Self);
+        Float::exp_m1(self) -> Self;
+        Float::ln_1p(self) -> Self;
+        Float::sinh(self) -> Self;
+        Float::cosh(self) -> Self;
+        Float::tanh(self) -> Self;
+        Float::asinh(self) -> Self;
+        Float::acosh(self) -> Self;
+        Float::atanh(self) -> Self;
+    }
+}

src/sign.rs

@@ -1,6 +1,7 @@
-use std::ops::Neg;
-use std::{f32, f64};
+use core::num::Wrapping;
+use core::ops::Neg;
 
+use float::FloatCore;
 use Num;
 
 /// Useful functions for signed numbers (i.e. numbers that can be negative).
@@ -73,22 +74,58 @@ macro_rules! signed_impl {
 
 signed_impl!(isize i8 i16 i32 i64);
 
+#[cfg(has_i128)]
+signed_impl!(i128);
+
+impl<T: Signed> Signed for Wrapping<T>
+where
+    Wrapping<T>: Num + Neg<Output = Wrapping<T>>,
+{
+    #[inline]
+    fn abs(&self) -> Self {
+        Wrapping(self.0.abs())
+    }
+
+    #[inline]
+    fn abs_sub(&self, other: &Self) -> Self {
+        Wrapping(self.0.abs_sub(&other.0))
+    }
+
+    #[inline]
+    fn signum(&self) -> Self {
+        Wrapping(self.0.signum())
+    }
+
+    #[inline]
+    fn is_positive(&self) -> bool {
+        self.0.is_positive()
+    }
+
+    #[inline]
+    fn is_negative(&self) -> bool {
+        self.0.is_negative()
+    }
+}
+
 macro_rules! signed_float_impl {
-    ($t:ty, $nan:expr, $inf:expr, $neg_inf:expr) => {
+    ($t:ty) => {
         impl Signed for $t {
             /// Computes the absolute value. Returns `NAN` if the number is `NAN`.
             #[inline]
             fn abs(&self) -> $t {
-                <$t>::abs(*self)
+                FloatCore::abs(*self)
             }
 
             /// The positive difference of two numbers. Returns `0.0` if the number is
             /// less than or equal to `other`, otherwise the difference between`self`
             /// and `other` is returned.
             #[inline]
-            #[allow(deprecated)]
             fn abs_sub(&self, other: &$t) -> $t {
-                <$t>::abs_sub(*self, *other)
+                if *self <= *other {
+                    0.
+                } else {
+                    *self - *other
+                }
             }
 
             /// # Returns
@@ -98,22 +135,26 @@ macro_rules! signed_float_impl {
             /// - `NAN` if the number is NaN
             #[inline]
             fn signum(&self) -> $t {
-                <$t>::signum(*self)
+                FloatCore::signum(*self)
             }
 
             /// Returns `true` if the number is positive, including `+0.0` and `INFINITY`
             #[inline]
-            fn is_positive(&self) -> bool { *self > 0.0 || (1.0 / *self) == $inf }
+            fn is_positive(&self) -> bool {
+                FloatCore::is_sign_positive(*self)
+            }
 
             /// Returns `true` if the number is negative, including `-0.0` and `NEG_INFINITY`
             #[inline]
-            fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == $neg_inf }
+            fn is_negative(&self) -> bool {
+                FloatCore::is_sign_negative(*self)
+            }
         }
-    }
+    };
 }
 
-signed_float_impl!(f32, f32::NAN, f32::INFINITY, f32::NEG_INFINITY);
-signed_float_impl!(f64, f64::NAN, f64::INFINITY, f64::NEG_INFINITY);
+signed_float_impl!(f32);
+signed_float_impl!(f64);
 
 /// Computes the absolute value.
 ///
@@ -147,7 +188,10 @@ pub fn abs_sub<T: Signed>(x: T, y: T) -> T {
 /// * `0` if the number is zero
 /// * `1` if the number is positive
 /// * `-1` if the number is negative
-#[inline(always)] pub fn signum<T: Signed>(value: T) -> T { value.signum() }
+#[inline(always)]
+pub fn signum<T: Signed>(value: T) -> T {
+    value.signum()
+}
 
 /// A trait for values which cannot be negative
 pub trait Unsigned: Num {}
@@ -159,3 +203,23 @@ macro_rules! empty_trait_impl {
 }
 
 empty_trait_impl!(Unsigned for usize u8 u16 u32 u64);
+#[cfg(has_i128)]
+empty_trait_impl!(Unsigned for u128);
+
+impl<T: Unsigned> Unsigned for Wrapping<T> where Wrapping<T>: Num {}
+
+#[test]
+fn unsigned_wrapping_is_unsigned() {
+    fn require_unsigned<T: Unsigned>(_: &T) {}
+    require_unsigned(&Wrapping(42_u32));
+}
+/*
+// Commenting this out since it doesn't compile on Rust 1.8,
+// because on this version Wrapping doesn't implement Neg and therefore can't
+// implement Signed.
+#[test]
+fn signed_wrapping_is_signed() {
+    fn require_signed<T: Signed>(_: &T) {}
+    require_signed(&Wrapping(-42));
+}
+*/

tests/cast.rs

@@ -0,0 +1,396 @@
+//! Tests of `num_traits::cast`.
+
+#![no_std]
+
+#[cfg(feature = "std")]
+#[macro_use]
+extern crate std;
+
+extern crate num_traits;
+
+use num_traits::cast::*;
+use num_traits::Bounded;
+
+use core::{f32, f64};
+#[cfg(has_i128)]
+use core::{i128, u128};
+use core::{i16, i32, i64, i8, isize};
+use core::{u16, u32, u64, u8, usize};
+
+use core::fmt::Debug;
+use core::mem;
+use core::num::Wrapping;
+
+#[test]
+fn to_primitive_float() {
+    let f32_toolarge = 1e39f64;
+    assert_eq!(f32_toolarge.to_f32(), None);
+    assert_eq!((f32::MAX as f64).to_f32(), Some(f32::MAX));
+    assert_eq!((-f32::MAX as f64).to_f32(), Some(-f32::MAX));
+    assert_eq!(f64::INFINITY.to_f32(), Some(f32::INFINITY));
+    assert_eq!((f64::NEG_INFINITY).to_f32(), Some(f32::NEG_INFINITY));
+    assert!((f64::NAN).to_f32().map_or(false, |f| f.is_nan()));
+}
+
+#[test]
+fn wrapping_to_primitive() {
+    macro_rules! test_wrapping_to_primitive {
+        ($($t:ty)+) => {
+            $({
+                let i: $t = 0;
+                let w = Wrapping(i);
+                assert_eq!(i.to_u8(),    w.to_u8());
+                assert_eq!(i.to_u16(),   w.to_u16());
+                assert_eq!(i.to_u32(),   w.to_u32());
+                assert_eq!(i.to_u64(),   w.to_u64());
+                assert_eq!(i.to_usize(), w.to_usize());
+                assert_eq!(i.to_i8(),    w.to_i8());
+                assert_eq!(i.to_i16(),   w.to_i16());
+                assert_eq!(i.to_i32(),   w.to_i32());
+                assert_eq!(i.to_i64(),   w.to_i64());
+                assert_eq!(i.to_isize(), w.to_isize());
+                assert_eq!(i.to_f32(),   w.to_f32());
+                assert_eq!(i.to_f64(),   w.to_f64());
+            })+
+        };
+    }
+
+    test_wrapping_to_primitive!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn wrapping_is_toprimitive() {
+    fn require_toprimitive<T: ToPrimitive>(_: &T) {}
+    require_toprimitive(&Wrapping(42));
+}
+
+#[test]
+fn wrapping_is_fromprimitive() {
+    fn require_fromprimitive<T: FromPrimitive>(_: &T) {}
+    require_fromprimitive(&Wrapping(42));
+}
+
+#[test]
+fn wrapping_is_numcast() {
+    fn require_numcast<T: NumCast>(_: &T) {}
+    require_numcast(&Wrapping(42));
+}
+
+#[test]
+fn as_primitive() {
+    let x: f32 = (1.625f64).as_();
+    assert_eq!(x, 1.625f32);
+
+    let x: f32 = (3.14159265358979323846f64).as_();
+    assert_eq!(x, 3.1415927f32);
+
+    let x: u8 = (768i16).as_();
+    assert_eq!(x, 0);
+}
+
+#[test]
+fn float_to_integer_checks_overflow() {
+    // This will overflow an i32
+    let source: f64 = 1.0e+123f64;
+
+    // Expect the overflow to be caught
+    assert_eq!(cast::<f64, i32>(source), None);
+}
+
+#[test]
+fn cast_to_int_checks_overflow() {
+    let big_f: f64 = 1.0e123;
+    let normal_f: f64 = 1.0;
+    let small_f: f64 = -1.0e123;
+    assert_eq!(None, cast::<f64, isize>(big_f));
+    assert_eq!(None, cast::<f64, i8>(big_f));
+    assert_eq!(None, cast::<f64, i16>(big_f));
+    assert_eq!(None, cast::<f64, i32>(big_f));
+    assert_eq!(None, cast::<f64, i64>(big_f));
+
+    assert_eq!(Some(normal_f as isize), cast::<f64, isize>(normal_f));
+    assert_eq!(Some(normal_f as i8), cast::<f64, i8>(normal_f));
+    assert_eq!(Some(normal_f as i16), cast::<f64, i16>(normal_f));
+    assert_eq!(Some(normal_f as i32), cast::<f64, i32>(normal_f));
+    assert_eq!(Some(normal_f as i64), cast::<f64, i64>(normal_f));
+
+    assert_eq!(None, cast::<f64, isize>(small_f));
+    assert_eq!(None, cast::<f64, i8>(small_f));
+    assert_eq!(None, cast::<f64, i16>(small_f));
+    assert_eq!(None, cast::<f64, i32>(small_f));
+    assert_eq!(None, cast::<f64, i64>(small_f));
+}
+
+#[test]
+fn cast_to_unsigned_int_checks_overflow() {
+    let big_f: f64 = 1.0e123;
+    let normal_f: f64 = 1.0;
+    let small_f: f64 = -1.0e123;
+    assert_eq!(None, cast::<f64, usize>(big_f));
+    assert_eq!(None, cast::<f64, u8>(big_f));
+    assert_eq!(None, cast::<f64, u16>(big_f));
+    assert_eq!(None, cast::<f64, u32>(big_f));
+    assert_eq!(None, cast::<f64, u64>(big_f));
+
+    assert_eq!(Some(normal_f as usize), cast::<f64, usize>(normal_f));
+    assert_eq!(Some(normal_f as u8), cast::<f64, u8>(normal_f));
+    assert_eq!(Some(normal_f as u16), cast::<f64, u16>(normal_f));
+    assert_eq!(Some(normal_f as u32), cast::<f64, u32>(normal_f));
+    assert_eq!(Some(normal_f as u64), cast::<f64, u64>(normal_f));
+
+    assert_eq!(None, cast::<f64, usize>(small_f));
+    assert_eq!(None, cast::<f64, u8>(small_f));
+    assert_eq!(None, cast::<f64, u16>(small_f));
+    assert_eq!(None, cast::<f64, u32>(small_f));
+    assert_eq!(None, cast::<f64, u64>(small_f));
+}
+
+#[test]
+#[cfg(has_i128)]
+fn cast_to_i128_checks_overflow() {
+    let big_f: f64 = 1.0e123;
+    let normal_f: f64 = 1.0;
+    let small_f: f64 = -1.0e123;
+    assert_eq!(None, cast::<f64, i128>(big_f));
+    assert_eq!(None, cast::<f64, u128>(big_f));
+
+    assert_eq!(Some(normal_f as i128), cast::<f64, i128>(normal_f));
+    assert_eq!(Some(normal_f as u128), cast::<f64, u128>(normal_f));
+
+    assert_eq!(None, cast::<f64, i128>(small_f));
+    assert_eq!(None, cast::<f64, u128>(small_f));
+}
+
+#[cfg(feature = "std")]
+fn dbg(args: ::core::fmt::Arguments) {
+    println!("{}", args);
+}
+
+#[cfg(not(feature = "std"))]
+fn dbg(_: ::core::fmt::Arguments) {}
+
+// Rust 1.8 doesn't handle cfg on macros correctly
+macro_rules! dbg { ($($tok:tt)*) => { dbg(format_args!($($tok)*)) } }
+
+macro_rules! float_test_edge {
+    ($f:ident -> $($t:ident)+) => { $({
+        dbg!("testing cast edge cases for {} -> {}", stringify!($f), stringify!($t));
+
+        let small = if $t::MIN == 0 || mem::size_of::<$t>() < mem::size_of::<$f>() {
+            $t::MIN as $f - 1.0
+        } else {
+            ($t::MIN as $f).raw_offset(1).floor()
+        };
+        let fmin = small.raw_offset(-1);
+        dbg!("  testing min {}\n\tvs. {:.0}\n\tand {:.0}", $t::MIN, fmin, small);
+        assert_eq!(Some($t::MIN), cast::<$f, $t>($t::MIN as $f));
+        assert_eq!(Some($t::MIN), cast::<$f, $t>(fmin));
+        assert_eq!(None, cast::<$f, $t>(small));
+
+        let (max, large) = if mem::size_of::<$t>() < mem::size_of::<$f>() {
+            ($t::MAX, $t::MAX as $f + 1.0)
+        } else {
+            let large = $t::MAX as $f; // rounds up!
+            let max = large.raw_offset(-1) as $t; // the next smallest possible
+            assert_eq!(max.count_ones(), $f::MANTISSA_DIGITS);
+            (max, large)
+        };
+        let fmax = large.raw_offset(-1);
+        dbg!("  testing max {}\n\tvs. {:.0}\n\tand {:.0}", max, fmax, large);
+        assert_eq!(Some(max), cast::<$f, $t>(max as $f));
+        assert_eq!(Some(max), cast::<$f, $t>(fmax));
+        assert_eq!(None, cast::<$f, $t>(large));
+
+        dbg!("  testing non-finite values");
+        assert_eq!(None, cast::<$f, $t>($f::NAN));
+        assert_eq!(None, cast::<$f, $t>($f::INFINITY));
+        assert_eq!(None, cast::<$f, $t>($f::NEG_INFINITY));
+    })+}
+}
+
+trait RawOffset: Sized {
+    type Raw;
+    fn raw_offset(self, offset: Self::Raw) -> Self;
+}
+
+impl RawOffset for f32 {
+    type Raw = i32;
+    fn raw_offset(self, offset: Self::Raw) -> Self {
+        unsafe {
+            let raw: Self::Raw = mem::transmute(self);
+            mem::transmute(raw + offset)
+        }
+    }
+}
+
+impl RawOffset for f64 {
+    type Raw = i64;
+    fn raw_offset(self, offset: Self::Raw) -> Self {
+        unsafe {
+            let raw: Self::Raw = mem::transmute(self);
+            mem::transmute(raw + offset)
+        }
+    }
+}
+
+#[test]
+fn cast_float_to_int_edge_cases() {
+    float_test_edge!(f32 -> isize i8 i16 i32 i64);
+    float_test_edge!(f32 -> usize u8 u16 u32 u64);
+    float_test_edge!(f64 -> isize i8 i16 i32 i64);
+    float_test_edge!(f64 -> usize u8 u16 u32 u64);
+}
+
+#[test]
+#[cfg(has_i128)]
+fn cast_float_to_i128_edge_cases() {
+    float_test_edge!(f32 -> i128 u128);
+    float_test_edge!(f64 -> i128 u128);
+}
+
+macro_rules! int_test_edge {
+    ($f:ident -> { $($t:ident)+ } with $BigS:ident $BigU:ident ) => { $({
+        fn test_edge() {
+            dbg!("testing cast edge cases for {} -> {}", stringify!($f), stringify!($t));
+
+            match ($f::MIN as $BigS).cmp(&($t::MIN as $BigS)) {
+                Greater => {
+                    assert_eq!(Some($f::MIN as $t), cast::<$f, $t>($f::MIN));
+                }
+                Equal => {
+                    assert_eq!(Some($t::MIN), cast::<$f, $t>($f::MIN));
+                }
+                Less => {
+                    let min = $t::MIN as $f;
+                    assert_eq!(Some($t::MIN), cast::<$f, $t>(min));
+                    assert_eq!(None, cast::<$f, $t>(min - 1));
+                }
+            }
+
+            match ($f::MAX as $BigU).cmp(&($t::MAX as $BigU)) {
+                Greater => {
+                    let max = $t::MAX as $f;
+                    assert_eq!(Some($t::MAX), cast::<$f, $t>(max));
+                    assert_eq!(None, cast::<$f, $t>(max + 1));
+                }
+                Equal => {
+                    assert_eq!(Some($t::MAX), cast::<$f, $t>($f::MAX));
+                }
+                Less => {
+                    assert_eq!(Some($f::MAX as $t), cast::<$f, $t>($f::MAX));
+                }
+            }
+        }
+        test_edge();
+    })+}
+}
+
+#[test]
+fn cast_int_to_int_edge_cases() {
+    use core::cmp::Ordering::*;
+
+    macro_rules! test_edge {
+        ($( $from:ident )+) => { $({
+            int_test_edge!($from -> { isize i8 i16 i32 i64 } with i64 u64);
+            int_test_edge!($from -> { usize u8 u16 u32 u64 } with i64 u64);
+        })+}
+    }
+
+    test_edge!(isize i8 i16 i32 i64);
+    test_edge!(usize u8 u16 u32 u64);
+}
+
+#[test]
+#[cfg(has_i128)]
+fn cast_int_to_128_edge_cases() {
+    use core::cmp::Ordering::*;
+
+    macro_rules! test_edge {
+        ($( $t:ident )+) => {
+            $(
+                int_test_edge!($t -> { i128 u128 } with i128 u128);
+            )+
+            int_test_edge!(i128 -> { $( $t )+ } with i128 u128);
+            int_test_edge!(u128 -> { $( $t )+ } with i128 u128);
+        }
+    }
+
+    test_edge!(isize i8 i16 i32 i64 i128);
+    test_edge!(usize u8 u16 u32 u64 u128);
+}
+
+#[test]
+fn newtype_from_primitive() {
+    #[derive(PartialEq, Debug)]
+    struct New<T>(T);
+
+    // minimal impl
+    impl<T: FromPrimitive> FromPrimitive for New<T> {
+        fn from_i64(n: i64) -> Option<Self> {
+            T::from_i64(n).map(New)
+        }
+
+        fn from_u64(n: u64) -> Option<Self> {
+            T::from_u64(n).map(New)
+        }
+    }
+
+    macro_rules! assert_eq_from {
+        ($( $from:ident )+) => {$(
+            assert_eq!(T::$from(Bounded::min_value()).map(New),
+                       New::<T>::$from(Bounded::min_value()));
+            assert_eq!(T::$from(Bounded::max_value()).map(New),
+                       New::<T>::$from(Bounded::max_value()));
+        )+}
+    }
+
+    fn check<T: PartialEq + Debug + FromPrimitive>() {
+        assert_eq_from!(from_i8 from_i16 from_i32 from_i64 from_isize);
+        assert_eq_from!(from_u8 from_u16 from_u32 from_u64 from_usize);
+        assert_eq_from!(from_f32 from_f64);
+    }
+
+    macro_rules! check {
+        ($( $ty:ty )+) => {$( check::<$ty>(); )+}
+    }
+    check!(i8 i16 i32 i64 isize);
+    check!(u8 u16 u32 u64 usize);
+}
+
+#[test]
+fn newtype_to_primitive() {
+    #[derive(PartialEq, Debug)]
+    struct New<T>(T);
+
+    // minimal impl
+    impl<T: ToPrimitive> ToPrimitive for New<T> {
+        fn to_i64(&self) -> Option<i64> {
+            self.0.to_i64()
+        }
+
+        fn to_u64(&self) -> Option<u64> {
+            self.0.to_u64()
+        }
+    }
+
+    macro_rules! assert_eq_to {
+        ($( $to:ident )+) => {$(
+            assert_eq!(T::$to(&Bounded::min_value()),
+                       New::<T>::$to(&New(Bounded::min_value())));
+            assert_eq!(T::$to(&Bounded::max_value()),
+                       New::<T>::$to(&New(Bounded::max_value())));
+        )+}
+    }
+
+    fn check<T: PartialEq + Debug + Bounded + ToPrimitive>() {
+        assert_eq_to!(to_i8 to_i16 to_i32 to_i64 to_isize);
+        assert_eq_to!(to_u8 to_u16 to_u32 to_u64 to_usize);
+        assert_eq_to!(to_f32 to_f64);
+    }
+
+    macro_rules! check {
+        ($( $ty:ty )+) => {$( check::<$ty>(); )+}
+    }
+    check!(i8 i16 i32 i64 isize);
+    check!(u8 u16 u32 u64 usize);
+}

traits/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-description = "Numeric traits for generic mathematics"
-documentation = "http://rust-num.github.io/num"
-homepage = "https://github.com/rust-num/num"
-keywords = ["mathematics", "numerics"]
-license = "MIT/Apache-2.0"
-repository = "https://github.com/rust-num/num"
-name = "num-traits"
-version = "0.1.35"
-
-[dependencies]

traits/src/bounds.rs

@@ -1,71 +0,0 @@
-use std::{usize, u8, u16, u32, u64};
-use std::{isize, i8, i16, i32, i64};
-use std::{f32, f64};
-
-/// Numbers which have upper and lower bounds
-pub trait Bounded {
-    // FIXME (#5527): These should be associated constants
-    /// returns the smallest finite number this type can represent
-    fn min_value() -> Self;
-    /// returns the largest finite number this type can represent
-    fn max_value() -> Self;
-}
-
-macro_rules! bounded_impl {
-    ($t:ty, $min:expr, $max:expr) => {
-        impl Bounded for $t {
-            #[inline]
-            fn min_value() -> $t { $min }
-
-            #[inline]
-            fn max_value() -> $t { $max }
-        }
-    }
-}
-
-bounded_impl!(usize, usize::MIN, usize::MAX);
-bounded_impl!(u8,    u8::MIN,    u8::MAX);
-bounded_impl!(u16,   u16::MIN,   u16::MAX);
-bounded_impl!(u32,   u32::MIN,   u32::MAX);
-bounded_impl!(u64,   u64::MIN,   u64::MAX);
-
-bounded_impl!(isize, isize::MIN, isize::MAX);
-bounded_impl!(i8,    i8::MIN,    i8::MAX);
-bounded_impl!(i16,   i16::MIN,   i16::MAX);
-bounded_impl!(i32,   i32::MIN,   i32::MAX);
-bounded_impl!(i64,   i64::MIN,   i64::MAX);
-
-bounded_impl!(f32, f32::MIN, f32::MAX);
-
-macro_rules! for_each_tuple_ {
-    ( $m:ident !! ) => (
-        $m! { }
-    );
-    ( $m:ident !! $h:ident, $($t:ident,)* ) => (
-        $m! { $h $($t)* }
-        for_each_tuple_! { $m !! $($t,)* }
-    );
-}
-macro_rules! for_each_tuple {
-    ( $m:ident ) => (
-        for_each_tuple_! { $m !! A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, }
-    );
-}
-
-macro_rules! bounded_tuple {
-    ( $($name:ident)* ) => (
-        impl<$($name: Bounded,)*> Bounded for ($($name,)*) {
-            #[inline]
-            fn min_value() -> Self {
-                ($($name::min_value(),)*)
-            }
-            #[inline]
-            fn max_value() -> Self {
-                ($($name::max_value(),)*)
-            }
-        }
-    );
-}
-
-for_each_tuple!(bounded_tuple);
-bounded_impl!(f64, f64::MIN, f64::MAX);

traits/src/cast.rs

@@ -1,450 +0,0 @@
-use std::mem::size_of;
-
-use identities::Zero;
-use bounds::Bounded;
-
-/// A generic trait for converting a value to a number.
-pub trait ToPrimitive {
-    /// Converts the value of `self` to an `isize`.
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        self.to_i64().and_then(|x| x.to_isize())
-    }
-
-    /// Converts the value of `self` to an `i8`.
-    #[inline]
-    fn to_i8(&self) -> Option<i8> {
-        self.to_i64().and_then(|x| x.to_i8())
-    }
-
-    /// Converts the value of `self` to an `i16`.
-    #[inline]
-    fn to_i16(&self) -> Option<i16> {
-        self.to_i64().and_then(|x| x.to_i16())
-    }
-
-    /// Converts the value of `self` to an `i32`.
-    #[inline]
-    fn to_i32(&self) -> Option<i32> {
-        self.to_i64().and_then(|x| x.to_i32())
-    }
-
-    /// Converts the value of `self` to an `i64`.
-    fn to_i64(&self) -> Option<i64>;
-
-    /// Converts the value of `self` to a `usize`.
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        self.to_u64().and_then(|x| x.to_usize())
-    }
-
-    /// Converts the value of `self` to an `u8`.
-    #[inline]
-    fn to_u8(&self) -> Option<u8> {
-        self.to_u64().and_then(|x| x.to_u8())
-    }
-
-    /// Converts the value of `self` to an `u16`.
-    #[inline]
-    fn to_u16(&self) -> Option<u16> {
-        self.to_u64().and_then(|x| x.to_u16())
-    }
-
-    /// Converts the value of `self` to an `u32`.
-    #[inline]
-    fn to_u32(&self) -> Option<u32> {
-        self.to_u64().and_then(|x| x.to_u32())
-    }
-
-    /// Converts the value of `self` to an `u64`.
-    #[inline]
-    fn to_u64(&self) -> Option<u64>;
-
-    /// Converts the value of `self` to an `f32`.
-    #[inline]
-    fn to_f32(&self) -> Option<f32> {
-        self.to_f64().and_then(|x| x.to_f32())
-    }
-
-    /// Converts the value of `self` to an `f64`.
-    #[inline]
-    fn to_f64(&self) -> Option<f64> {
-        self.to_i64().and_then(|x| x.to_f64())
-    }
-}
-
-macro_rules! impl_to_primitive_int_to_int {
-    ($SrcT:ty, $DstT:ty, $slf:expr) => (
-        {
-            if size_of::<$SrcT>() <= size_of::<$DstT>() {
-                Some($slf as $DstT)
-            } else {
-                let n = $slf as i64;
-                let min_value: $DstT = Bounded::min_value();
-                let max_value: $DstT = Bounded::max_value();
-                if min_value as i64 <= n && n <= max_value as i64 {
-                    Some($slf as $DstT)
-                } else {
-                    None
-                }
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_int_to_uint {
-    ($SrcT:ty, $DstT:ty, $slf:expr) => (
-        {
-            let zero: $SrcT = Zero::zero();
-            let max_value: $DstT = Bounded::max_value();
-            if zero <= $slf && $slf as u64 <= max_value as u64 {
-                Some($slf as $DstT)
-            } else {
-                None
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_int {
-    ($T:ty) => (
-        impl ToPrimitive for $T {
-            #[inline]
-            fn to_isize(&self) -> Option<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
-            #[inline]
-            fn to_i8(&self) -> Option<i8> { impl_to_primitive_int_to_int!($T, i8, *self) }
-            #[inline]
-            fn to_i16(&self) -> Option<i16> { impl_to_primitive_int_to_int!($T, i16, *self) }
-            #[inline]
-            fn to_i32(&self) -> Option<i32> { impl_to_primitive_int_to_int!($T, i32, *self) }
-            #[inline]
-            fn to_i64(&self) -> Option<i64> { impl_to_primitive_int_to_int!($T, i64, *self) }
-
-            #[inline]
-            fn to_usize(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
-            #[inline]
-            fn to_u8(&self) -> Option<u8> { impl_to_primitive_int_to_uint!($T, u8, *self) }
-            #[inline]
-            fn to_u16(&self) -> Option<u16> { impl_to_primitive_int_to_uint!($T, u16, *self) }
-            #[inline]
-            fn to_u32(&self) -> Option<u32> { impl_to_primitive_int_to_uint!($T, u32, *self) }
-            #[inline]
-            fn to_u64(&self) -> Option<u64> { impl_to_primitive_int_to_uint!($T, u64, *self) }
-
-            #[inline]
-            fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
-            #[inline]
-            fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
-        }
-    )
-}
-
-impl_to_primitive_int!(isize);
-impl_to_primitive_int!(i8);
-impl_to_primitive_int!(i16);
-impl_to_primitive_int!(i32);
-impl_to_primitive_int!(i64);
-
-macro_rules! impl_to_primitive_uint_to_int {
-    ($DstT:ty, $slf:expr) => (
-        {
-            let max_value: $DstT = Bounded::max_value();
-            if $slf as u64 <= max_value as u64 {
-                Some($slf as $DstT)
-            } else {
-                None
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_uint_to_uint {
-    ($SrcT:ty, $DstT:ty, $slf:expr) => (
-        {
-            if size_of::<$SrcT>() <= size_of::<$DstT>() {
-                Some($slf as $DstT)
-            } else {
-                let zero: $SrcT = Zero::zero();
-                let max_value: $DstT = Bounded::max_value();
-                if zero <= $slf && $slf as u64 <= max_value as u64 {
-                    Some($slf as $DstT)
-                } else {
-                    None
-                }
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_uint {
-    ($T:ty) => (
-        impl ToPrimitive for $T {
-            #[inline]
-            fn to_isize(&self) -> Option<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
-            #[inline]
-            fn to_i8(&self) -> Option<i8> { impl_to_primitive_uint_to_int!(i8, *self) }
-            #[inline]
-            fn to_i16(&self) -> Option<i16> { impl_to_primitive_uint_to_int!(i16, *self) }
-            #[inline]
-            fn to_i32(&self) -> Option<i32> { impl_to_primitive_uint_to_int!(i32, *self) }
-            #[inline]
-            fn to_i64(&self) -> Option<i64> { impl_to_primitive_uint_to_int!(i64, *self) }
-
-            #[inline]
-            fn to_usize(&self) -> Option<usize> {
-                impl_to_primitive_uint_to_uint!($T, usize, *self)
-            }
-            #[inline]
-            fn to_u8(&self) -> Option<u8> { impl_to_primitive_uint_to_uint!($T, u8, *self) }
-            #[inline]
-            fn to_u16(&self) -> Option<u16> { impl_to_primitive_uint_to_uint!($T, u16, *self) }
-            #[inline]
-            fn to_u32(&self) -> Option<u32> { impl_to_primitive_uint_to_uint!($T, u32, *self) }
-            #[inline]
-            fn to_u64(&self) -> Option<u64> { impl_to_primitive_uint_to_uint!($T, u64, *self) }
-
-            #[inline]
-            fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
-            #[inline]
-            fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
-        }
-    )
-}
-
-impl_to_primitive_uint!(usize);
-impl_to_primitive_uint!(u8);
-impl_to_primitive_uint!(u16);
-impl_to_primitive_uint!(u32);
-impl_to_primitive_uint!(u64);
-
-macro_rules! impl_to_primitive_float_to_float {
-    ($SrcT:ident, $DstT:ident, $slf:expr) => (
-        if size_of::<$SrcT>() <= size_of::<$DstT>() {
-            Some($slf as $DstT)
-        } else {
-            // Make sure the value is in range for the cast.
-            // NaN and +-inf are cast as they are.
-            let n = $slf as f64;
-            let max_value: $DstT = ::std::$DstT::MAX;
-            if !n.is_finite() || (-max_value as f64 <= n && n <= max_value as f64) {
-                Some($slf as $DstT)
-            } else {
-                None
-            }
-        }
-    )
-}
-
-macro_rules! impl_to_primitive_float {
-    ($T:ident) => (
-        impl ToPrimitive for $T {
-            #[inline]
-            fn to_isize(&self) -> Option<isize> { Some(*self as isize) }
-            #[inline]
-            fn to_i8(&self) -> Option<i8> { Some(*self as i8) }
-            #[inline]
-            fn to_i16(&self) -> Option<i16> { Some(*self as i16) }
-            #[inline]
-            fn to_i32(&self) -> Option<i32> { Some(*self as i32) }
-            #[inline]
-            fn to_i64(&self) -> Option<i64> { Some(*self as i64) }
-
-            #[inline]
-            fn to_usize(&self) -> Option<usize> { Some(*self as usize) }
-            #[inline]
-            fn to_u8(&self) -> Option<u8> { Some(*self as u8) }
-            #[inline]
-            fn to_u16(&self) -> Option<u16> { Some(*self as u16) }
-            #[inline]
-            fn to_u32(&self) -> Option<u32> { Some(*self as u32) }
-            #[inline]
-            fn to_u64(&self) -> Option<u64> { Some(*self as u64) }
-
-            #[inline]
-            fn to_f32(&self) -> Option<f32> { impl_to_primitive_float_to_float!($T, f32, *self) }
-            #[inline]
-            fn to_f64(&self) -> Option<f64> { impl_to_primitive_float_to_float!($T, f64, *self) }
-        }
-    )
-}
-
-impl_to_primitive_float!(f32);
-impl_to_primitive_float!(f64);
-
-/// A generic trait for converting a number to a value.
-pub trait FromPrimitive: Sized {
-    /// Convert an `isize` to return an optional value of this type. If the
-    /// value cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_isize(n: isize) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Convert an `i8` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_i8(n: i8) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Convert an `i16` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_i16(n: i16) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Convert an `i32` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_i32(n: i32) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-
-    /// Convert an `i64` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    fn from_i64(n: i64) -> Option<Self>;
-
-    /// Convert a `usize` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_usize(n: usize) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Convert an `u8` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_u8(n: u8) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Convert an `u16` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_u16(n: u16) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Convert an `u32` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_u32(n: u32) -> Option<Self> {
-        FromPrimitive::from_u64(n as u64)
-    }
-
-    /// Convert an `u64` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    fn from_u64(n: u64) -> Option<Self>;
-
-    /// Convert a `f32` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_f32(n: f32) -> Option<Self> {
-        FromPrimitive::from_f64(n as f64)
-    }
-
-    /// Convert a `f64` to return an optional value of this type. If the
-    /// type cannot be represented by this value, the `None` is returned.
-    #[inline]
-    fn from_f64(n: f64) -> Option<Self> {
-        FromPrimitive::from_i64(n as i64)
-    }
-}
-
-macro_rules! impl_from_primitive {
-    ($T:ty, $to_ty:ident) => (
-        #[allow(deprecated)]
-        impl FromPrimitive for $T {
-            #[inline] fn from_i8(n: i8) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_i16(n: i16) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_i32(n: i32) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() }
-
-            #[inline] fn from_u8(n: u8) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_u16(n: u16) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_u32(n: u32) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_u64(n: u64) -> Option<$T> { n.$to_ty() }
-
-            #[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() }
-            #[inline] fn from_f64(n: f64) -> Option<$T> { n.$to_ty() }
-        }
-    )
-}
-
-impl_from_primitive!(isize, to_isize);
-impl_from_primitive!(i8,    to_i8);
-impl_from_primitive!(i16,   to_i16);
-impl_from_primitive!(i32,   to_i32);
-impl_from_primitive!(i64,   to_i64);
-impl_from_primitive!(usize, to_usize);
-impl_from_primitive!(u8,    to_u8);
-impl_from_primitive!(u16,   to_u16);
-impl_from_primitive!(u32,   to_u32);
-impl_from_primitive!(u64,   to_u64);
-impl_from_primitive!(f32,   to_f32);
-impl_from_primitive!(f64,   to_f64);
-
-/// Cast from one machine scalar to another.
-///
-/// # Examples
-///
-/// ```
-/// # use num_traits as num;
-/// let twenty: f32 = num::cast(0x14).unwrap();
-/// assert_eq!(twenty, 20f32);
-/// ```
-///
-#[inline]
-pub fn cast<T: NumCast, U: NumCast>(n: T) -> Option<U> {
-    NumCast::from(n)
-}
-
-/// An interface for casting between machine scalars.
-pub trait NumCast: Sized + ToPrimitive {
-    /// Creates a number from another value that can be converted into
-    /// a primitive via the `ToPrimitive` trait.
-    fn from<T: ToPrimitive>(n: T) -> Option<Self>;
-}
-
-macro_rules! impl_num_cast {
-    ($T:ty, $conv:ident) => (
-        impl NumCast for $T {
-            #[inline]
-            #[allow(deprecated)]
-            fn from<N: ToPrimitive>(n: N) -> Option<$T> {
-                // `$conv` could be generated using `concat_idents!`, but that
-                // macro seems to be broken at the moment
-                n.$conv()
-            }
-        }
-    )
-}
-
-impl_num_cast!(u8,    to_u8);
-impl_num_cast!(u16,   to_u16);
-impl_num_cast!(u32,   to_u32);
-impl_num_cast!(u64,   to_u64);
-impl_num_cast!(usize, to_usize);
-impl_num_cast!(i8,    to_i8);
-impl_num_cast!(i16,   to_i16);
-impl_num_cast!(i32,   to_i32);
-impl_num_cast!(i64,   to_i64);
-impl_num_cast!(isize, to_isize);
-impl_num_cast!(f32,   to_f32);
-impl_num_cast!(f64,   to_f64);
-
-
-#[test]
-fn to_primitive_float() {
-    use std::f32;
-    use std::f64;
-
-    let f32_toolarge = 1e39f64;
-    assert_eq!(f32_toolarge.to_f32(), None);
-    assert_eq!((f32::MAX as f64).to_f32(), Some(f32::MAX));
-    assert_eq!((-f32::MAX as f64).to_f32(), Some(-f32::MAX));
-    assert_eq!(f64::INFINITY.to_f32(), Some(f32::INFINITY));
-    assert_eq!((f64::NEG_INFINITY).to_f32(), Some(f32::NEG_INFINITY));
-    assert!((f64::NAN).to_f32().map_or(false, |f| f.is_nan()));
-}

traits/src/identities.rs

@@ -1,104 +0,0 @@
-use std::ops::{Add, Mul};
-
-/// Defines an additive identity element for `Self`.
-pub trait Zero: Sized + Add<Self, Output = Self> {
-    /// Returns the additive identity element of `Self`, `0`.
-    ///
-    /// # Laws
-    ///
-    /// ```{.text}
-    /// a + 0 = a       ∀ a ∈ Self
-    /// 0 + a = a       ∀ a ∈ Self
-    /// ```
-    ///
-    /// # Purity
-    ///
-    /// This function should return the same result at all times regardless of
-    /// external mutable state, for example values stored in TLS or in
-    /// `static mut`s.
-    // FIXME (#5527): This should be an associated constant
-    fn zero() -> Self;
-
-    /// Returns `true` if `self` is equal to the additive identity.
-    #[inline]
-    fn is_zero(&self) -> bool;
-}
-
-macro_rules! zero_impl {
-    ($t:ty, $v:expr) => {
-        impl Zero for $t {
-            #[inline]
-            fn zero() -> $t { $v }
-            #[inline]
-            fn is_zero(&self) -> bool { *self == $v }
-        }
-    }
-}
-
-zero_impl!(usize, 0usize);
-zero_impl!(u8,    0u8);
-zero_impl!(u16,   0u16);
-zero_impl!(u32,   0u32);
-zero_impl!(u64,   0u64);
-
-zero_impl!(isize, 0isize);
-zero_impl!(i8,    0i8);
-zero_impl!(i16,   0i16);
-zero_impl!(i32,   0i32);
-zero_impl!(i64,   0i64);
-
-zero_impl!(f32, 0.0f32);
-zero_impl!(f64, 0.0f64);
-
-/// Defines a multiplicative identity element for `Self`.
-pub trait One: Sized + Mul<Self, Output = Self> {
-    /// Returns the multiplicative identity element of `Self`, `1`.
-    ///
-    /// # Laws
-    ///
-    /// ```{.text}
-    /// a * 1 = a       ∀ a ∈ Self
-    /// 1 * a = a       ∀ a ∈ Self
-    /// ```
-    ///
-    /// # Purity
-    ///
-    /// This function should return the same result at all times regardless of
-    /// external mutable state, for example values stored in TLS or in
-    /// `static mut`s.
-    // FIXME (#5527): This should be an associated constant
-    fn one() -> Self;
-}
-
-macro_rules! one_impl {
-    ($t:ty, $v:expr) => {
-        impl One for $t {
-            #[inline]
-            fn one() -> $t { $v }
-        }
-    }
-}
-
-one_impl!(usize, 1usize);
-one_impl!(u8,    1u8);
-one_impl!(u16,   1u16);
-one_impl!(u32,   1u32);
-one_impl!(u64,   1u64);
-
-one_impl!(isize, 1isize);
-one_impl!(i8,    1i8);
-one_impl!(i16,   1i16);
-one_impl!(i32,   1i32);
-one_impl!(i64,   1i64);
-
-one_impl!(f32, 1.0f32);
-one_impl!(f64, 1.0f64);
-
-
-// Some helper functions provided for backwards compatibility.
-
-/// Returns the additive identity, `0`.
-#[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() }
-
-/// Returns the multiplicative identity, `1`.
-#[inline(always)] pub fn one<T: One>() -> T { One::one() }

traits/src/lib.rs

@@ -1,236 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Numeric traits for generic mathematics
-
-use std::ops::{Add, Sub, Mul, Div, Rem};
-
-pub use bounds::Bounded;
-pub use float::{Float, FloatConst};
-pub use identities::{Zero, One, zero, one};
-pub use ops::checked::*;
-pub use ops::saturating::Saturating;
-pub use sign::{Signed, Unsigned, abs, abs_sub, signum};
-pub use cast::*;
-pub use int::PrimInt;
-pub use pow::{pow, checked_pow};
-
-pub mod identities;
-pub mod sign;
-pub mod ops;
-pub mod bounds;
-pub mod float;
-pub mod cast;
-pub mod int;
-pub mod pow;
-
-/// The base trait for numeric types
-pub trait Num: PartialEq + Zero + One
-    + Add<Output = Self> + Sub<Output = Self>
-    + Mul<Output = Self> + Div<Output = Self> + Rem<Output = Self>
-{
-    type FromStrRadixErr;
-
-    /// Convert from a string and radix <= 36.
-    fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>;
-}
-
-macro_rules! int_trait_impl {
-    ($name:ident for $($t:ty)*) => ($(
-        impl $name for $t {
-            type FromStrRadixErr = ::std::num::ParseIntError;
-            #[inline]
-            fn from_str_radix(s: &str, radix: u32)
-                              -> Result<Self, ::std::num::ParseIntError>
-            {
-                <$t>::from_str_radix(s, radix)
-            }
-        }
-    )*)
-}
-int_trait_impl!(Num for usize u8 u16 u32 u64 isize i8 i16 i32 i64);
-
-#[derive(Debug)]
-pub enum FloatErrorKind {
-    Empty,
-    Invalid,
-}
-// FIXME: std::num::ParseFloatError is stable in 1.0, but opaque to us,
-// so there's not really any way for us to reuse it.
-#[derive(Debug)]
-pub struct ParseFloatError {
-    pub kind: FloatErrorKind,
-}
-
-// FIXME: The standard library from_str_radix on floats was deprecated, so we're stuck
-// with this implementation ourselves until we want to make a breaking change.
-// (would have to drop it from `Num` though)
-macro_rules! float_trait_impl {
-    ($name:ident for $($t:ty)*) => ($(
-        impl $name for $t {
-            type FromStrRadixErr = ParseFloatError;
-
-            fn from_str_radix(src: &str, radix: u32)
-                              -> Result<Self, Self::FromStrRadixErr>
-            {
-                use self::FloatErrorKind::*;
-                use self::ParseFloatError as PFE;
-
-                // Special values
-                match src {
-                    "inf"   => return Ok(Float::infinity()),
-                    "-inf"  => return Ok(Float::neg_infinity()),
-                    "NaN"   => return Ok(Float::nan()),
-                    _       => {},
-                }
-
-                fn slice_shift_char(src: &str) -> Option<(char, &str)> {
-                    src.chars().nth(0).map(|ch| (ch, &src[1..]))
-                }
-
-                let (is_positive, src) =  match slice_shift_char(src) {
-                    None             => return Err(PFE { kind: Empty }),
-                    Some(('-', ""))  => return Err(PFE { kind: Empty }),
-                    Some(('-', src)) => (false, src),
-                    Some((_, _))     => (true,  src),
-                };
-
-                // The significand to accumulate
-                let mut sig = if is_positive { 0.0 } else { -0.0 };
-                // Necessary to detect overflow
-                let mut prev_sig = sig;
-                let mut cs = src.chars().enumerate();
-                // Exponent prefix and exponent index offset
-                let mut exp_info = None::<(char, usize)>;
-
-                // Parse the integer part of the significand
-                for (i, c) in cs.by_ref() {
-                    match c.to_digit(radix) {
-                        Some(digit) => {
-                            // shift significand one digit left
-                            sig = sig * (radix as $t);
-
-                            // add/subtract current digit depending on sign
-                            if is_positive {
-                                sig = sig + ((digit as isize) as $t);
-                            } else {
-                                sig = sig - ((digit as isize) as $t);
-                            }
-
-                            // Detect overflow by comparing to last value, except
-                            // if we've not seen any non-zero digits.
-                            if prev_sig != 0.0 {
-                                if is_positive && sig <= prev_sig
-                                    { return Ok(Float::infinity()); }
-                                if !is_positive && sig >= prev_sig
-                                    { return Ok(Float::neg_infinity()); }
-
-                                // Detect overflow by reversing the shift-and-add process
-                                if is_positive && (prev_sig != (sig - digit as $t) / radix as $t)
-                                    { return Ok(Float::infinity()); }
-                                if !is_positive && (prev_sig != (sig + digit as $t) / radix as $t)
-                                    { return Ok(Float::neg_infinity()); }
-                            }
-                            prev_sig = sig;
-                        },
-                        None => match c {
-                            'e' | 'E' | 'p' | 'P' => {
-                                exp_info = Some((c, i + 1));
-                                break;  // start of exponent
-                            },
-                            '.' => {
-                                break;  // start of fractional part
-                            },
-                            _ => {
-                                return Err(PFE { kind: Invalid });
-                            },
-                        },
-                    }
-                }
-
-                // If we are not yet at the exponent parse the fractional
-                // part of the significand
-                if exp_info.is_none() {
-                    let mut power = 1.0;
-                    for (i, c) in cs.by_ref() {
-                        match c.to_digit(radix) {
-                            Some(digit) => {
-                                // Decrease power one order of magnitude
-                                power = power / (radix as $t);
-                                // add/subtract current digit depending on sign
-                                sig = if is_positive {
-                                    sig + (digit as $t) * power
-                                } else {
-                                    sig - (digit as $t) * power
-                                };
-                                // Detect overflow by comparing to last value
-                                if is_positive && sig < prev_sig
-                                    { return Ok(Float::infinity()); }
-                                if !is_positive && sig > prev_sig
-                                    { return Ok(Float::neg_infinity()); }
-                                prev_sig = sig;
-                            },
-                            None => match c {
-                                'e' | 'E' | 'p' | 'P' => {
-                                    exp_info = Some((c, i + 1));
-                                    break; // start of exponent
-                                },
-                                _ => {
-                                    return Err(PFE { kind: Invalid });
-                                },
-                            },
-                        }
-                    }
-                }
-
-                // Parse and calculate the exponent
-                let exp = match exp_info {
-                    Some((c, offset)) => {
-                        let base = match c {
-                            'E' | 'e' if radix == 10 => 10.0,
-                            'P' | 'p' if radix == 16 => 2.0,
-                            _ => return Err(PFE { kind: Invalid }),
-                        };
-
-                        // Parse the exponent as decimal integer
-                        let src = &src[offset..];
-                        let (is_positive, exp) = match slice_shift_char(src) {
-                            Some(('-', src)) => (false, src.parse::<usize>()),
-                            Some(('+', src)) => (true,  src.parse::<usize>()),
-                            Some((_, _))     => (true,  src.parse::<usize>()),
-                            None             => return Err(PFE { kind: Invalid }),
-                        };
-
-                        match (is_positive, exp) {
-                            (true,  Ok(exp)) => base.powi(exp as i32),
-                            (false, Ok(exp)) => 1.0 / base.powi(exp as i32),
-                            (_, Err(_))      => return Err(PFE { kind: Invalid }),
-                        }
-                    },
-                    None => 1.0, // no exponent
-                };
-
-                Ok(sig * exp)
-            }
-        }
-    )*)
-}
-float_trait_impl!(Num for f32 f64);
-
-#[test]
-fn from_str_radix_unwrap() {
-    // The Result error must impl Debug to allow unwrap()
-
-    let i: i32 = Num::from_str_radix("0", 10).unwrap();
-    assert_eq!(i, 0);
-
-    let f: f32 = Num::from_str_radix("0.0", 10).unwrap();
-    assert_eq!(f, 0.0);
-}

traits/src/ops/checked.rs

@@ -1,91 +0,0 @@
-use std::ops::{Add, Sub, Mul, Div};
-
-/// Performs addition that returns `None` instead of wrapping around on
-/// overflow.
-pub trait CheckedAdd: Sized + Add<Self, Output=Self> {
-    /// Adds two numbers, checking for overflow. If overflow happens, `None` is
-    /// returned.
-    fn checked_add(&self, v: &Self) -> Option<Self>;
-}
-
-macro_rules! checked_impl {
-    ($trait_name:ident, $method:ident, $t:ty) => {
-        impl $trait_name for $t {
-            #[inline]
-            fn $method(&self, v: &$t) -> Option<$t> {
-                <$t>::$method(*self, *v)
-            }
-        }
-    }
-}
-
-checked_impl!(CheckedAdd, checked_add, u8);
-checked_impl!(CheckedAdd, checked_add, u16);
-checked_impl!(CheckedAdd, checked_add, u32);
-checked_impl!(CheckedAdd, checked_add, u64);
-checked_impl!(CheckedAdd, checked_add, usize);
-
-checked_impl!(CheckedAdd, checked_add, i8);
-checked_impl!(CheckedAdd, checked_add, i16);
-checked_impl!(CheckedAdd, checked_add, i32);
-checked_impl!(CheckedAdd, checked_add, i64);
-checked_impl!(CheckedAdd, checked_add, isize);
-
-/// Performs subtraction that returns `None` instead of wrapping around on underflow.
-pub trait CheckedSub: Sized + Sub<Self, Output=Self> {
-    /// Subtracts two numbers, checking for underflow. If underflow happens,
-    /// `None` is returned.
-    fn checked_sub(&self, v: &Self) -> Option<Self>;
-}
-
-checked_impl!(CheckedSub, checked_sub, u8);
-checked_impl!(CheckedSub, checked_sub, u16);
-checked_impl!(CheckedSub, checked_sub, u32);
-checked_impl!(CheckedSub, checked_sub, u64);
-checked_impl!(CheckedSub, checked_sub, usize);
-
-checked_impl!(CheckedSub, checked_sub, i8);
-checked_impl!(CheckedSub, checked_sub, i16);
-checked_impl!(CheckedSub, checked_sub, i32);
-checked_impl!(CheckedSub, checked_sub, i64);
-checked_impl!(CheckedSub, checked_sub, isize);
-
-/// Performs multiplication that returns `None` instead of wrapping around on underflow or
-/// overflow.
-pub trait CheckedMul: Sized + Mul<Self, Output=Self> {
-    /// Multiplies two numbers, checking for underflow or overflow. If underflow
-    /// or overflow happens, `None` is returned.
-    fn checked_mul(&self, v: &Self) -> Option<Self>;
-}
-
-checked_impl!(CheckedMul, checked_mul, u8);
-checked_impl!(CheckedMul, checked_mul, u16);
-checked_impl!(CheckedMul, checked_mul, u32);
-checked_impl!(CheckedMul, checked_mul, u64);
-checked_impl!(CheckedMul, checked_mul, usize);
-
-checked_impl!(CheckedMul, checked_mul, i8);
-checked_impl!(CheckedMul, checked_mul, i16);
-checked_impl!(CheckedMul, checked_mul, i32);
-checked_impl!(CheckedMul, checked_mul, i64);
-checked_impl!(CheckedMul, checked_mul, isize);
-
-/// Performs division that returns `None` instead of panicking on division by zero and instead of
-/// wrapping around on underflow and overflow.
-pub trait CheckedDiv: Sized + Div<Self, Output=Self> {
-    /// Divides two numbers, checking for underflow, overflow and division by
-    /// zero. If any of that happens, `None` is returned.
-    fn checked_div(&self, v: &Self) -> Option<Self>;
-}
-
-checked_impl!(CheckedDiv, checked_div, u8);
-checked_impl!(CheckedDiv, checked_div, u16);
-checked_impl!(CheckedDiv, checked_div, u32);
-checked_impl!(CheckedDiv, checked_div, u64);
-checked_impl!(CheckedDiv, checked_div, usize);
-
-checked_impl!(CheckedDiv, checked_div, i8);
-checked_impl!(CheckedDiv, checked_div, i16);
-checked_impl!(CheckedDiv, checked_div, i32);
-checked_impl!(CheckedDiv, checked_div, i64);
-checked_impl!(CheckedDiv, checked_div, isize);

traits/src/ops/mod.rs

@@ -1,2 +0,0 @@
-pub mod saturating;
-pub mod checked;

traits/src/pow.rs

@@ -1,73 +0,0 @@
-use std::ops::Mul;
-use {One, CheckedMul};
-
-/// Raises a value to the power of exp, using exponentiation by squaring.
-///
-/// # Example
-///
-/// ```rust
-/// use num_traits::pow;
-///
-/// assert_eq!(pow(2i8, 4), 16);
-/// assert_eq!(pow(6u8, 3), 216);
-/// ```
-#[inline]
-pub fn pow<T: Clone + One + Mul<T, Output = T>>(mut base: T, mut exp: usize) -> T {
-    if exp == 0 { return T::one() }
-
-    while exp & 1 == 0 {
-        base = base.clone() * base;
-        exp >>= 1;
-    }
-    if exp == 1 { return base }
-
-    let mut acc = base.clone();
-    while exp > 1 {
-        exp >>= 1;
-        base = base.clone() * base;
-        if exp & 1 == 1 {
-            acc = acc * base.clone();
-        }
-    }
-    acc
-}
-
-/// Raises a value to the power of exp, returning `None` if an overflow occurred.
-///
-/// Otherwise same as the `pow` function.
-///
-/// # Example
-///
-/// ```rust
-/// use num_traits::checked_pow;
-///
-/// assert_eq!(checked_pow(2i8, 4), Some(16));
-/// assert_eq!(checked_pow(7i8, 8), None);
-/// assert_eq!(checked_pow(7u32, 8), Some(5_764_801));
-/// ```
-#[inline]
-pub fn checked_pow<T: Clone + One + CheckedMul>(mut base: T, mut exp: usize) -> Option<T> {
-    if exp == 0 { return Some(T::one()) }
-
-    macro_rules! optry {
-        ( $ expr : expr ) => {
-            if let Some(val) = $expr { val } else { return None }
-        }
-    }
-
-    while exp & 1 == 0 {
-        base = optry!(base.checked_mul(&base));
-        exp >>= 1;
-    }
-    if exp == 1 { return Some(base) }
-
-    let mut acc = base.clone();
-    while exp > 1 {
-        exp >>= 1;
-        base = optry!(base.checked_mul(&base));
-        if exp & 1 == 1 {
-            acc = optry!(acc.checked_mul(&base));
-        }
-    }
-    Some(acc)
-}