Extract integer module

Author: hauleth

Cargo.toml

@@ -21,6 +21,9 @@ serde = { version = "^0.7.0", optional = true }
 [dependencies.num-traits]
 path = "./traits"
 
+[dependencies.num-integer]
+path = "./integer"
+
 [dev-dependencies]
 # Some tests of non-rand functionality still use rand because the tests
 # themselves are randomized.

integer/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
-name = "integer"
+name = "num-integer"
 version = "0.1.0"
 authors = ["Łukasz Jan Niemier <[email protected]>"]
 
-[dependencies]
+[dependencies.num-traits]
+path = "../traits"

integer/src/lib.rs

@@ -10,7 +10,9 @@
 
 //! Integer trait and functions.
 
-use {Num, Signed};
+extern crate num_traits as traits;
+
+use traits::{Num, Signed};
 
 pub trait Integer
     : Sized
@@ -179,7 +181,7 @@ macro_rules! impl_integer_for_isize {
         impl Integer for $T {
             /// Floored integer division
             #[inline]
-            fn div_floor(&self, other: &$T) -> $T {
+            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) {
@@ -191,7 +193,7 @@ macro_rules! impl_integer_for_isize {
 
             /// Floored integer modulo
             #[inline]
-            fn mod_floor(&self, other: &$T) -> $T {
+            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 {
@@ -203,7 +205,7 @@ macro_rules! impl_integer_for_isize {
 
             /// Calculates `div_floor` and `mod_floor` simultaneously
             #[inline]
-            fn div_mod_floor(&self, other: &$T) -> ($T,$T) {
+            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) {
@@ -216,7 +218,7 @@ macro_rules! impl_integer_for_isize {
             /// Calculates the Greatest Common Divisor (GCD) of the number and
             /// `other`. The result is always positive.
             #[inline]
-            fn gcd(&self, other: &$T) -> $T {
+            fn gcd(&self, other: &Self) -> Self {
                 // Use Stein's algorithm
                 let mut m = *self;
                 let mut n = *other;
@@ -233,7 +235,7 @@ macro_rules! impl_integer_for_isize {
                 // 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 == <$T>::min_value() || n == <$T>::min_value() {
+                if m == Self::min_value() || n == Self::min_value() {
                     return (1 << shift).abs()
                 }
 
@@ -257,18 +259,22 @@ macro_rules! impl_integer_for_isize {
             /// Calculates the Lowest Common Multiple (LCM) of the number and
             /// `other`.
             #[inline]
-            fn lcm(&self, other: &$T) -> $T {
+            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: &$T) -> bool { return self.is_multiple_of(other); }
+            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: &$T) -> bool { *self % *other == 0 }
+            fn is_multiple_of(&self, other: &Self) -> bool {
+                *self % *other == 0
+            }
 
             /// Returns `true` if the number is divisible by `2`
             #[inline]
@@ -280,7 +286,7 @@ macro_rules! impl_integer_for_isize {
 
             /// Simultaneous truncated integer division and modulus.
             #[inline]
-            fn div_rem(&self, other: &$T) -> ($T, $T) {
+            fn div_rem(&self, other: &Self) -> (Self, Self) {
                 (*self / *other, *self % *other)
             }
         }
@@ -295,7 +301,7 @@ macro_rules! impl_integer_for_isize {
             /// - `d`: denominator (divisor)
             /// - `qr`: quotient and remainder
             #[cfg(test)]
-            fn test_division_rule((n,d): ($T,$T), (q,r): ($T,$T)) {
+            fn test_division_rule((n,d): ($T, $T), (q,r): ($T, $T)) {
                 assert_eq!(d * q + r, n);
             }
 
@@ -475,15 +481,19 @@ macro_rules! impl_integer_for_usize {
         impl Integer for $T {
             /// Unsigned integer division. Returns the same result as `div` (`/`).
             #[inline]
-            fn div_floor(&self, other: &$T) -> $T { *self / *other }
+            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: &$T) -> $T { *self % *other }
+            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: &$T) -> $T {
+            fn gcd(&self, other: &Self) -> Self {
                 // Use Stein's algorithm
                 let mut m = *self;
                 let mut n = *other;
@@ -507,29 +517,37 @@ macro_rules! impl_integer_for_usize {
 
             /// Calculates the Lowest Common Multiple (LCM) of the number and `other`.
             #[inline]
-            fn lcm(&self, other: &$T) -> $T {
+            fn lcm(&self, other: &Self) -> Self {
                 (*self * *other) / self.gcd(other)
             }
 
             /// Deprecated, use `is_multiple_of` instead.
             #[inline]
-            fn divides(&self, other: &$T) -> bool { return self.is_multiple_of(other); }
+            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: &$T) -> bool { *self % *other == 0 }
+            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 }
+            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() }
+            fn is_odd(&self) -> bool {
+                !self.is_even()
+            }
 
             /// Simultaneous truncated integer division and modulus.
             #[inline]
-            fn div_rem(&self, other: &$T) -> ($T, $T) {
+            fn div_rem(&self, other: &Self) -> (Self, Self) {
                 (*self / *other, *self % *other)
             }
         }