Extract rational

.travis.yml

@@ -5,12 +5,9 @@ rust:
   - nightly
 sudo: false
 script:
-  - cargo build --verbose
+  - make test
-  - cargo test --verbose
-  - .travis/test_features.sh
   - |
-    [ $TRAVIS_RUST_VERSION != nightly ] ||
+    [ $TRAVIS_RUST_VERSION != nightly ] || .travis/test_nightly.sh
-    .travis/test_nightly.sh
   - cargo doc
 after_success: |
   [ $TRAVIS_BRANCH = master ] &&

.travis/test_features.sh

@@ -3,7 +3,5 @@
 set -ex
 
 for feature in '' bigint rational complex; do
-  cargo build --verbose --no-default-features --features="$feature"
   cargo test --verbose --no-default-features --features="$feature"
 done
-

Cargo.toml

@@ -19,12 +19,16 @@ name = "shootout-pidigits"
 [dependencies]
 
 [dependencies.num-bigint]
-optional = false
+optional = true
 path = "bigint"
 
 [dependencies.num-integer]
 path = "./integer"
 
+[dependencies.num-rational]
+optional = true
+path = "rational"
+
 [dependencies.num-traits]
 path = "./traits"
 
@@ -46,7 +50,7 @@ version = "^0.7.0"
 version = "0.3.8"
 
 [features]
-bigint = []
+bigint = ["num-bigint"]
 complex = []
 default = ["bigint", "complex", "rand", "rational", "rustc-serialize"]
-rational = []
+rational = ["num-rational"]

Makefile

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

bigint/Cargo.toml

@@ -6,11 +6,9 @@ version = "0.1.0"
 [dependencies]
 
 [dependencies.num-integer]
-optional = false
 path = "../integer"
 
 [dependencies.num-traits]
-optional = false
 path = "../traits"
 
 [dependencies.rand]
@@ -20,3 +18,6 @@ version = "0.3.14"
 [dependencies.serde]
 optional = true
 version = "0.7.0"
+
+[features]
+default = ["rand"]

bigint/src/lib.rs

@@ -18,8 +18,9 @@
 //!
 //! ## Example
 //!
-//! ```rust
+//! ```rust,ignore
-//! use num::{BigUint, Zero, One};
+//! use num_bigint::BigUint;
+//! use num_traits::{Zero, One};
 //! use std::mem::replace;
 //!
 //! // Calculate large fibonacci numbers.
@@ -42,11 +43,11 @@
 //!
 //! ```rust
 //! extern crate rand;
-//! extern crate num;
+//! extern crate num_bigint as bigint;
 //!
 //! # #[cfg(feature = "rand")]
 //! # fn main() {
-//! use num::bigint::{ToBigInt, RandBigInt};
+//! use bigint::{ToBigInt, RandBigInt};
 //!
 //! let mut rng = rand::thread_rng();
 //! let a = rng.gen_bigint(1000);
@@ -64,6 +65,9 @@
 //! # }
 //! ```
 
+#[cfg(any(feature = "rand", test))]
+extern crate rand;
+
 extern crate num_integer as integer;
 extern crate num_traits as traits;
 
@@ -75,6 +79,7 @@ use std::num::ParseIntError;
 use std::ops::{Add, BitAnd, BitOr, BitXor, Div, Mul, Neg, Rem, Shl, Shr, Sub};
 use std::str::{self, FromStr};
 use std::fmt;
+use std::hash;
 use std::cmp::Ordering::{self, Less, Greater, Equal};
 use std::{f32, f64};
 use std::{u8, i64, u64};
@@ -1655,7 +1660,7 @@ impl BigUint {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::BigUint;
+    /// use num_bigint::BigUint;
     ///
     /// assert_eq!(BigUint::from_bytes_be(b"A"),
     ///            BigUint::parse_bytes(b"65", 10).unwrap());
@@ -1694,7 +1699,7 @@ impl BigUint {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::BigUint;
+    /// use num_bigint::BigUint;
     ///
     /// let i = BigUint::parse_bytes(b"1125", 10).unwrap();
     /// assert_eq!(i.to_bytes_le(), vec![101, 4]);
@@ -1713,7 +1718,7 @@ impl BigUint {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::BigUint;
+    /// use num_bigint::BigUint;
     ///
     /// let i = BigUint::parse_bytes(b"1125", 10).unwrap();
     /// assert_eq!(i.to_bytes_be(), vec![4, 101]);
@@ -1731,7 +1736,7 @@ impl BigUint {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::BigUint;
+    /// use num_bigint::BigUint;
     ///
     /// let i = BigUint::parse_bytes(b"ff", 16).unwrap();
     /// assert_eq!(i.to_str_radix(16), "ff");
@@ -1748,7 +1753,7 @@ impl BigUint {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::{BigUint, ToBigUint};
+    /// use num_bigint::{BigUint, ToBigUint};
     ///
     /// assert_eq!(BigUint::parse_bytes(b"1234", 10), ToBigUint::to_biguint(&1234));
     /// assert_eq!(BigUint::parse_bytes(b"ABCD", 16), ToBigUint::to_biguint(&0xABCD));
@@ -2764,7 +2769,7 @@ impl BigInt {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::{BigInt, Sign};
+    /// use num_bigint::{BigInt, Sign};
     ///
     /// assert_eq!(BigInt::from_bytes_be(Sign::Plus, b"A"),
     ///            BigInt::parse_bytes(b"65", 10).unwrap());
@@ -2793,7 +2798,7 @@ impl BigInt {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::{ToBigInt, Sign};
+    /// use num_bigint::{ToBigInt, Sign};
     ///
     /// let i = -1125.to_bigint().unwrap();
     /// assert_eq!(i.to_bytes_le(), (Sign::Minus, vec![101, 4]));
@@ -2808,7 +2813,7 @@ impl BigInt {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::{ToBigInt, Sign};
+    /// use num_bigint::{ToBigInt, Sign};
     ///
     /// let i = -1125.to_bigint().unwrap();
     /// assert_eq!(i.to_bytes_be(), (Sign::Minus, vec![4, 101]));
@@ -2824,7 +2829,7 @@ impl BigInt {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::BigInt;
+    /// use num_bigint::BigInt;
     ///
     /// let i = BigInt::parse_bytes(b"ff", 16).unwrap();
     /// assert_eq!(i.to_str_radix(16), "ff");
@@ -2846,7 +2851,7 @@ impl BigInt {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::{ToBigInt, Sign};
+    /// use num_bigint::{ToBigInt, Sign};
     ///
     /// assert_eq!(ToBigInt::to_bigint(&1234).unwrap().sign(), Sign::Plus);
     /// assert_eq!(ToBigInt::to_bigint(&-4321).unwrap().sign(), Sign::Minus);
@@ -2862,7 +2867,7 @@ impl BigInt {
     /// # Examples
     ///
     /// ```
-    /// use num::bigint::{BigInt, ToBigInt};
+    /// use num_bigint::{BigInt, ToBigInt};
     ///
     /// assert_eq!(BigInt::parse_bytes(b"1234", 10), ToBigInt::to_bigint(&1234));
     /// assert_eq!(BigInt::parse_bytes(b"ABCD", 16), ToBigInt::to_bigint(&0xABCD));
@@ -2935,9 +2940,17 @@ impl From<ParseIntError> for ParseBigIntError {
     }
 }
 
+#[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()
+}
+
 #[cfg(test)]
 mod biguint_tests {
-    use Integer;
+    use integer::Integer;
     use super::{BigDigit, BigUint, ToBigUint, big_digit};
     use super::{BigInt, RandBigInt, ToBigInt};
     use super::Sign::Plus;
@@ -2950,9 +2963,9 @@ mod biguint_tests {
     use std::{u8, u16, u32, u64, usize};
 
     use rand::thread_rng;
-    use {Num, Zero, One, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv};
+    use traits::{Num, Zero, One, CheckedAdd, CheckedSub, CheckedMul, CheckedDiv, ToPrimitive,
-    use {ToPrimitive, FromPrimitive};
+                 FromPrimitive, Float};
-    use Float;
+
 
     /// Assert that an op works for all val/ref combinations
     macro_rules! assert_op {
@@ -3083,10 +3096,10 @@ mod biguint_tests {
         let c = BigUint::new(vec![1]);
         let d = BigUint::new(vec![1, 0, 0, 0, 0, 0]);
         let e = BigUint::new(vec![0, 0, 0, 0, 0, 1]);
-        assert!(::hash(&a) == ::hash(&b));
+        assert!(super::hash(&a) == super::hash(&b));
-        assert!(::hash(&b) != ::hash(&c));
+        assert!(super::hash(&b) != super::hash(&c));
-        assert!(::hash(&c) == ::hash(&d));
+        assert!(super::hash(&c) == super::hash(&d));
-        assert!(::hash(&d) != ::hash(&e));
+        assert!(super::hash(&d) != super::hash(&e));
     }
 
     const BIT_TESTS: &'static [(&'static [BigDigit],
@@ -4173,7 +4186,6 @@ mod biguint_tests {
 
 #[cfg(test)]
 mod bigint_tests {
-    use Integer;
     use super::{BigDigit, BigUint, ToBigUint};
     use super::{Sign, BigInt, RandBigInt, ToBigInt, big_digit};
     use super::Sign::{Minus, NoSign, Plus};
@@ -4187,8 +4199,8 @@ mod bigint_tests {
 
     use rand::thread_rng;
 
-    use {Zero, One, Signed, ToPrimitive, FromPrimitive, Num};
+    use integer::Integer;
-    use Float;
+    use traits::{Zero, One, Signed, ToPrimitive, FromPrimitive, Num, Float};
 
     /// Assert that an op works for all val/ref combinations
     macro_rules! assert_op {
@@ -4334,11 +4346,11 @@ mod bigint_tests {
         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!(super::hash(&a) == super::hash(&b));
-        assert!(::hash(&b) != ::hash(&c));
+        assert!(super::hash(&b) != super::hash(&c));
-        assert!(::hash(&c) == ::hash(&d));
+        assert!(super::hash(&c) == super::hash(&d));
-        assert!(::hash(&d) != ::hash(&e));
+        assert!(super::hash(&d) != super::hash(&e));
-        assert!(::hash(&c) != ::hash(&f));
+        assert!(super::hash(&c) != super::hash(&f));
     }
 
     #[test]

integer/src/lib.rs

@@ -20,7 +20,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// assert!(( 8).div_floor(& 3) ==  2);
     /// assert!(( 8).div_floor(&-3) == -3);
     /// assert!((-8).div_floor(& 3) == -3);
@@ -36,7 +36,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// Floored integer modulo, satisfying:
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// # let n = 1; let d = 1;
     /// assert!(n.div_floor(&d) * d + n.mod_floor(&d) == n)
     /// ~~~
@@ -44,7 +44,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// assert!(( 8).mod_floor(& 3) ==  2);
     /// assert!(( 8).mod_floor(&-3) == -1);
     /// assert!((-8).mod_floor(& 3) ==  1);
@@ -62,7 +62,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// assert_eq!(6.gcd(&8), 2);
     /// assert_eq!(7.gcd(&3), 1);
     /// ~~~
@@ -73,7 +73,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// assert_eq!(7.lcm(&3), 21);
     /// assert_eq!(2.lcm(&4), 4);
     /// ~~~
@@ -87,7 +87,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// assert_eq!(9.is_multiple_of(&3), true);
     /// assert_eq!(3.is_multiple_of(&9), false);
     /// ~~~
@@ -98,7 +98,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// assert_eq!(3.is_even(), false);
     /// assert_eq!(4.is_even(), true);
     /// ~~~
@@ -109,7 +109,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # use num_integer::Integer;
     /// assert_eq!(3.is_odd(), true);
     /// assert_eq!(4.is_odd(), false);
     /// ~~~
@@ -121,7 +121,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # 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));
@@ -141,7 +141,7 @@ pub trait Integer: Sized + Num + PartialOrd + Ord + Eq {
     /// # Examples
     ///
     /// ~~~
-    /// # use num::Integer;
+    /// # 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));

rational/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+authors = ["Łukasz Jan Niemier <lukasz@niemier.pl>"]
+name = "num-rational"
+version = "0.1.0"
+
+[dependencies]
+
+[dependencies.num-bigint]
+optional = true
+path = "../bigint"
+
+[dependencies.num-integer]
+path = "../integer"
+
+[dependencies.num-traits]
+path = "../traits"
+
+[dependencies.serde]
+optional = true
+version = "0.7.0"
+
+[features]
+default = ["bigint"]
+bigint = ["num-bigint"]

src/lib.rs

@@ -59,7 +59,10 @@
 
 extern crate num_traits;
 extern crate num_integer;
+#[cfg(feature = "num-bigint")]
 extern crate num_bigint;
+#[cfg(feature = "num-rational")]
+extern crate num_rational;
 
 #[cfg(feature = "rustc-serialize")]
 extern crate rustc_serialize;
@@ -73,11 +76,11 @@ extern crate rand;
 #[cfg(feature = "serde")]
 extern crate serde;
 
-#[cfg(feature = "bigint")]
+#[cfg(feature = "num-bigint")]
 pub use bigint::{BigInt, BigUint};
-#[cfg(feature = "rational")]
+#[cfg(feature = "num-rational")]
 pub use rational::Rational;
-#[cfg(all(feature = "rational", feature="bigint"))]
+#[cfg(all(feature = "num-rational", feature="num-bigint"))]
 pub use rational::BigRational;
 #[cfg(feature = "complex")]
 pub use complex::Complex;
@@ -91,14 +94,14 @@ pub use traits::{Num, Zero, One, Signed, Unsigned, Bounded,
 
 use std::ops::{Mul};
 
-#[cfg(feature = "bigint")]
+#[cfg(feature = "num-bigint")]
-pub mod bigint { pub use num_bigint::*; }
+pub use num_bigint as bigint;
 pub mod complex;
-pub mod integer { pub use num_integer::*; }
+pub use num_integer as integers;
 pub mod iter;
-pub mod traits { pub use num_traits::*; }
+pub use num_traits as traits;
-#[cfg(feature = "rational")]
+#[cfg(feature = "num-rational")]
-pub mod rational;
+pub use num_rational as rational;
 
 /// Returns the additive identity, `0`.
 #[inline(always)] pub fn zero<T: Zero>() -> T { Zero::zero() }
@@ -210,11 +213,3 @@ pub fn checked_pow<T: Clone + One + CheckedMul>(mut base: T, mut exp: usize) ->
     }
     Some(acc)
 }
-
-#[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()
-}

traits/src/cast.rs

@@ -388,8 +388,7 @@ impl_from_primitive!(f64,   to_f64);
 /// # Examples
 ///
 /// ```
-/// use num;
+/// # use num_traits as num;
-///
 /// let twenty: f32 = num::cast(0x14).unwrap();
 /// assert_eq!(twenty, 20f32);
 /// ```

traits/src/float.rs

@@ -14,7 +14,7 @@ pub trait Float
     /// Returns the `NaN` value.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let nan: f32 = Float::nan();
     ///
@@ -24,7 +24,7 @@ pub trait Float
     /// Returns the infinite value.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f32;
     ///
     /// let infinity: f32 = Float::infinity();
@@ -37,7 +37,7 @@ pub trait Float
     /// Returns the negative infinite value.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f32;
     ///
     /// let neg_infinity: f32 = Float::neg_infinity();
@@ -50,7 +50,7 @@ pub trait Float
     /// Returns `-0.0`.
     ///
     /// ```
-    /// use num::traits::{Zero, Float};
+    /// use num_traits::{Zero, Float};
     ///
     /// let inf: f32 = Float::infinity();
     /// let zero: f32 = Zero::zero();
@@ -65,7 +65,7 @@ pub trait Float
     /// Returns the smallest finite value that this type can represent.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x: f64 = Float::min_value();
@@ -77,7 +77,7 @@ pub trait Float
     /// Returns the smallest positive, normalized value that this type can represent.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x: f64 = Float::min_positive_value();
@@ -89,7 +89,7 @@ pub trait Float
     /// Returns the largest finite value that this type can represent.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x: f64 = Float::max_value();
@@ -100,7 +100,7 @@ pub trait Float
     /// Returns `true` if this value is `NaN` and false otherwise.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let nan = f64::NAN;
@@ -115,7 +115,7 @@ pub trait Float
     /// false otherwise.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f32;
     ///
     /// let f = 7.0f32;
@@ -134,7 +134,7 @@ pub trait Float
     /// Returns `true` if this number is neither infinite nor `NaN`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f32;
     ///
     /// let f = 7.0f32;
@@ -154,7 +154,7 @@ pub trait Float
     /// [subnormal][subnormal], or `NaN`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f32;
     ///
     /// let min = f32::MIN_POSITIVE; // 1.17549435e-38f32
@@ -179,7 +179,7 @@ pub trait Float
     /// predicate instead.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::num::FpCategory;
     /// use std::f32;
     ///
@@ -194,7 +194,7 @@ pub trait Float
     /// Returns the largest integer less than or equal to a number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let f = 3.99;
     /// let g = 3.0;
@@ -207,7 +207,7 @@ pub trait Float
     /// Returns the smallest integer greater than or equal to a number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let f = 3.01;
     /// let g = 4.0;
@@ -221,7 +221,7 @@ pub trait Float
     /// `0.0`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let f = 3.3;
     /// let g = -3.3;
@@ -234,7 +234,7 @@ pub trait Float
     /// Return the integer part of a number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let f = 3.3;
     /// let g = -3.7;
@@ -247,7 +247,7 @@ pub trait Float
     /// Returns the fractional part of a number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 3.5;
     /// let y = -3.5;
@@ -263,7 +263,7 @@ pub trait Float
     /// number is `Float::nan()`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x = 3.5;
@@ -286,7 +286,7 @@ pub trait Float
     /// - `Float::nan()` if the number is `Float::nan()`
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let f = 3.5;
@@ -302,7 +302,7 @@ pub trait Float
     /// `Float::infinity()`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let nan: f64 = f64::NAN;
@@ -321,7 +321,7 @@ pub trait Float
     /// `Float::neg_infinity()`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let nan = f64::NAN;
@@ -341,7 +341,7 @@ pub trait Float
     /// a separate multiplication operation followed by an add.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let m = 10.0;
     /// let x = 4.0;
@@ -356,7 +356,7 @@ pub trait Float
     /// Take the reciprocal (inverse) of a number, `1/x`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 2.0;
     /// let abs_difference = (x.recip() - (1.0/x)).abs();
@@ -370,7 +370,7 @@ pub trait Float
     /// Using this function is generally faster than using `powf`
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 2.0;
     /// let abs_difference = (x.powi(2) - x*x).abs();
@@ -382,7 +382,7 @@ pub trait Float
     /// Raise a number to a floating point power.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 2.0;
     /// let abs_difference = (x.powf(2.0) - x*x).abs();
@@ -396,7 +396,7 @@ pub trait Float
     /// Returns NaN if `self` is a negative number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let positive = 4.0;
     /// let negative = -4.0;
@@ -411,7 +411,7 @@ pub trait Float
     /// Returns `e^(self)`, (the exponential function).
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let one = 1.0;
     /// // e^1
@@ -427,7 +427,7 @@ pub trait Float
     /// Returns `2^(self)`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let f = 2.0;
     ///
@@ -441,7 +441,7 @@ pub trait Float
     /// Returns the natural logarithm of the number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let one = 1.0;
     /// // e^1
@@ -457,7 +457,7 @@ pub trait Float
     /// Returns the logarithm of the number with respect to an arbitrary base.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let ten = 10.0;
     /// let two = 2.0;
@@ -476,7 +476,7 @@ pub trait Float
     /// Returns the base 2 logarithm of the number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let two = 2.0;
     ///
@@ -490,7 +490,7 @@ pub trait Float
     /// Returns the base 10 logarithm of the number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let ten = 10.0;
     ///
@@ -504,7 +504,7 @@ pub trait Float
     /// Returns the maximum of the two numbers.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 1.0;
     /// let y = 2.0;
@@ -516,7 +516,7 @@ pub trait Float
     /// Returns the minimum of the two numbers.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 1.0;
     /// let y = 2.0;
@@ -531,7 +531,7 @@ pub trait Float
     /// * Else: `self - other`
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 3.0;
     /// let y = -3.0;
@@ -547,7 +547,7 @@ pub trait Float
     /// Take the cubic root of a number.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 8.0;
     ///
@@ -562,7 +562,7 @@ pub trait Float
     /// legs of length `x` and `y`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 2.0;
     /// let y = 3.0;
@@ -577,7 +577,7 @@ pub trait Float
     /// Computes the sine of a number (in radians).
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x = f64::consts::PI/2.0;
@@ -591,7 +591,7 @@ pub trait Float
     /// Computes the cosine of a number (in radians).
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x = 2.0*f64::consts::PI;
@@ -605,7 +605,7 @@ pub trait Float
     /// Computes the tangent of a number (in radians).
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x = f64::consts::PI/4.0;
@@ -620,7 +620,7 @@ pub trait Float
     /// [-1, 1].
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let f = f64::consts::PI / 2.0;
@@ -637,7 +637,7 @@ pub trait Float
     /// [-1, 1].
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let f = f64::consts::PI / 4.0;
@@ -653,7 +653,7 @@ pub trait Float
     /// range [-pi/2, pi/2];
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let f = 1.0;
     ///
@@ -672,7 +672,7 @@ pub trait Float
     /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let pi = f64::consts::PI;
@@ -697,7 +697,7 @@ pub trait Float
     /// `(sin(x), cos(x))`.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x = f64::consts::PI/4.0;
@@ -715,7 +715,7 @@ pub trait Float
     /// number is close to zero.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 7.0;
     ///
@@ -730,7 +730,7 @@ pub trait Float
     /// the operations were performed separately.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let x = f64::consts::E - 1.0;
@@ -745,7 +745,7 @@ pub trait Float
     /// Hyperbolic sine function.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let e = f64::consts::E;
@@ -763,7 +763,7 @@ pub trait Float
     /// Hyperbolic cosine function.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let e = f64::consts::E;
@@ -781,7 +781,7 @@ pub trait Float
     /// Hyperbolic tangent function.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let e = f64::consts::E;
@@ -799,7 +799,7 @@ pub trait Float
     /// Inverse hyperbolic sine function.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 1.0;
     /// let f = x.sinh().asinh();
@@ -813,7 +813,7 @@ pub trait Float
     /// Inverse hyperbolic cosine function.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let x = 1.0;
     /// let f = x.cosh().acosh();
@@ -827,7 +827,7 @@ pub trait Float
     /// Inverse hyperbolic tangent function.
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     /// use std::f64;
     ///
     /// let e = f64::consts::E;
@@ -845,7 +845,7 @@ pub trait Float
     /// The floating point encoding is documented in the [Reference][floating-point].
     ///
     /// ```
-    /// use num::traits::Float;
+    /// use num_traits::Float;
     ///
     /// let num = 2.0f32;
     ///

traits/src/int.rs

@@ -28,7 +28,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0b01001100u8;
     ///
@@ -41,7 +41,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0b01001100u8;
     ///
@@ -55,7 +55,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0b0101000u16;
     ///
@@ -69,7 +69,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0b0101000u16;
     ///
@@ -83,7 +83,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     /// let m = 0x3456789ABCDEF012u64;
@@ -98,7 +98,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     /// let m = 0xDEF0123456789ABCu64;
@@ -115,7 +115,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     /// let m = 0x3456789ABCDEF000u64;
@@ -132,7 +132,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0xFEDCBA9876543210u64;
     /// let m = 0xFFFFEDCBA9876543u64;
@@ -149,7 +149,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFi64;
     /// let m = 0x3456789ABCDEF000i64;
@@ -166,7 +166,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0xFEDCBA9876543210i64;
     /// let m = 0x000FEDCBA9876543i64;
@@ -180,7 +180,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     /// let m = 0xEFCDAB8967452301u64;
@@ -196,7 +196,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
@@ -215,7 +215,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
@@ -234,7 +234,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
@@ -253,7 +253,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// let n = 0x0123456789ABCDEFu64;
     ///
@@ -270,7 +270,7 @@ pub trait PrimInt
     /// # Examples
     ///
     /// ```
-    /// use num::traits::PrimInt;
+    /// use num_traits::PrimInt;
     ///
     /// assert_eq!(2i32.pow(4), 16);
     /// ```