---

yaml
---
r: 159584
b: refs/heads/auto
c: de938b6
h: refs/heads/master
v: v3

Author: brendanzab

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: e965ba85ca689ad77f63b7f0af9d7e337dcb4825
+refs/heads/auto: de938b6ca1a2b6b6df65d5935c765a7c25fbce84
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/etc/vim/syntax/rust.vim

@@ -97,7 +97,7 @@ syn keyword rustTrait FromIterator IntoIterator Extend ExactSize
 syn keyword rustTrait Iterator DoubleEndedIterator
 syn keyword rustTrait RandomAccessIterator CloneableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator
-syn keyword rustTrait NumCast Signed Int UnsignedInt Float
+syn keyword rustTrait NumCast Int SignedInt UnsignedInt Float
 syn keyword rustTrait FloatMath ToPrimitive FromPrimitive
 syn keyword rustTrait Box
 syn keyword rustTrait GenericPath Path PosixPath WindowsPath

branches/auto/src/libcore/cmp.rs

@@ -19,6 +19,8 @@
 //! operators, you could do the following:
 //!
 //! ```rust
+//! use core::num::SignedInt;
+//!
 //! // Our type.
 //! struct SketchyNum {
 //!     num : int

branches/auto/src/libcore/fmt/mod.rs

@@ -620,7 +620,7 @@ impl<'a, T> Pointer for &'a mut T {
 macro_rules! floating(($ty:ident) => {
     impl Float for $ty {
         fn fmt(&self, fmt: &mut Formatter) -> Result {
-            use num::{Float, Signed};
+            use num::Float;
 
             let digits = match fmt.precision {
                 Some(i) => float::DigExact(i),
@@ -641,7 +641,7 @@ macro_rules! floating(($ty:ident) => {
 
     impl LowerExp for $ty {
         fn fmt(&self, fmt: &mut Formatter) -> Result {
-            use num::{Float, Signed};
+            use num::Float;
 
             let digits = match fmt.precision {
                 Some(i) => float::DigExact(i),
@@ -662,7 +662,7 @@ macro_rules! floating(($ty:ident) => {
 
     impl UpperExp for $ty {
         fn fmt(&self, fmt: &mut Formatter) -> Result {
-            use num::{Float, Signed};
+            use num::Float;
 
             let digits = match fmt.precision {
                 Some(i) => float::DigExact(i),

branches/auto/src/libcore/iter.rs

@@ -573,6 +573,8 @@ pub trait Iterator<A> {
     /// # Example
     ///
     /// ```rust
+    /// use core::num::SignedInt;
+    ///
     /// let xs = [-3i, 0, 1, 5, -10];
     /// assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
     /// ```
@@ -597,6 +599,8 @@ pub trait Iterator<A> {
     /// # Example
     ///
     /// ```rust
+    /// use core::num::SignedInt;
+    ///
     /// let xs = [-3i, 0, 1, 5, -10];
     /// assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
     /// ```

branches/auto/src/libcore/num/f32.rs

@@ -242,6 +242,41 @@ impl Float for f32 {
     #[inline]
     fn fract(self) -> f32 { self - self.trunc() }
 
+    /// Computes the absolute value of `self`. Returns `Float::nan()` if the
+    /// number is `Float::nan()`.
+    #[inline]
+    fn abs(self) -> f32 {
+        unsafe { intrinsics::fabsf32(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()`
+    #[inline]
+    fn signum(self) -> f32 {
+        if self.is_nan() {
+            Float::nan()
+        } else {
+            unsafe { intrinsics::copysignf32(1.0, self) }
+        }
+    }
+
+    /// Returns `true` if `self` is positive, including `+0.0` and
+    /// `Float::infinity()`.
+    #[inline]
+    fn is_positive(self) -> bool {
+        self > 0.0 || (1.0 / self) == Float::infinity()
+    }
+
+    /// Returns `true` if `self` is negative, including `-0.0` and
+    /// `Float::neg_infinity()`.
+    #[inline]
+    fn is_negative(self) -> bool {
+        self < 0.0 || (1.0 / self) == Float::neg_infinity()
+    }
+
     /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
     /// error. This produces a more accurate result with better performance than
     /// a separate multiplication operation followed by an add.
@@ -254,6 +289,7 @@ impl Float for f32 {
     #[inline]
     fn recip(self) -> f32 { 1.0 / self }
 
+    #[inline]
     fn powi(self, n: i32) -> f32 {
         unsafe { intrinsics::powif32(self, n) }
     }

branches/auto/src/libcore/num/f64.rs

@@ -248,6 +248,41 @@ impl Float for f64 {
     #[inline]
     fn fract(self) -> f64 { self - self.trunc() }
 
+    /// Computes the absolute value of `self`. Returns `Float::nan()` if the
+    /// number is `Float::nan()`.
+    #[inline]
+    fn abs(self) -> f64 {
+        unsafe { intrinsics::fabsf64(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()`
+    #[inline]
+    fn signum(self) -> f64 {
+        if self.is_nan() {
+            Float::nan()
+        } else {
+            unsafe { intrinsics::copysignf64(1.0, self) }
+        }
+    }
+
+    /// Returns `true` if `self` is positive, including `+0.0` and
+    /// `Float::infinity()`.
+    #[inline]
+    fn is_positive(self) -> bool {
+        self > 0.0 || (1.0 / self) == Float::infinity()
+    }
+
+    /// Returns `true` if `self` is negative, including `-0.0` and
+    /// `Float::neg_infinity()`.
+    #[inline]
+    fn is_negative(self) -> bool {
+        self < 0.0 || (1.0 / self) == Float::neg_infinity()
+    }
+
     /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
     /// error. This produces a more accurate result with better performance than
     /// a separate multiplication operation followed by an add.

branches/auto/src/libcore/num/float_macros.rs

@@ -13,6 +13,7 @@
 
 macro_rules! assert_approx_eq(
     ($a:expr, $b:expr) => ({
+        use num::Float;
         let (a, b) = (&$a, &$b);
         assert!((*a - *b).abs() < 1.0e-6,
                 "{} is not approximately equal to {}", *a, *b);

branches/auto/src/libcore/num/mod.rs

@@ -33,113 +33,6 @@ pub fn div_rem<T: Div<T, T> + Rem<T, T>>(x: T, y: T) -> (T, T) {
     (x / y, x % y)
 }
 
-/// A built-in signed number.
-pub trait Signed: Neg<Self> {
-    /// Computes the absolute value of `self`.
-    fn abs(self) -> Self;
-
-    /// Returns a number (either `-1`, `0` or `1`) representing sign of `self`.
-    fn signum(self) -> Self;
-
-    /// Returns `true` if `self` is a positive value.
-    fn is_positive(self) -> bool;
-
-    /// Returns `true` if `self` is a negative value.
-    fn is_negative(self) -> bool;
-}
-
-macro_rules! signed_int_impl {
-    ($T:ty) => {
-        impl Signed for $T {
-            /// Computes the absolute value. `Int::min_value()` will be returned
-            /// if the number is `Int::min_value()`.
-            #[inline]
-            fn abs(self) -> $T {
-                if self.is_negative() { -self } else { self }
-            }
-
-            /// # Returns
-            ///
-            /// - `0` if the number is zero
-            /// - `1` if the number is positive
-            /// - `-1` if the number is negative
-            #[inline]
-            fn signum(self) -> $T {
-                match self {
-                    n if n > 0 =>  1,
-                    0          =>  0,
-                    _          => -1,
-                }
-            }
-
-            /// Returns `true` if `self` is positive and `false` if the number
-            /// is zero or negative.
-            #[inline]
-            fn is_positive(self) -> bool { self > 0 }
-
-            /// Returns `true` if `self` is negative and `false` if the number
-            /// is zero or positive.
-            #[inline]
-            fn is_negative(self) -> bool { self < 0 }
-        }
-    }
-}
-
-signed_int_impl!(i8)
-signed_int_impl!(i16)
-signed_int_impl!(i32)
-signed_int_impl!(i64)
-signed_int_impl!(int)
-
-macro_rules! signed_float_impl {
-    ($T:ty, $fabs:path, $fcopysign:path) => {
-        impl Signed for $T {
-            /// Computes the absolute value. Returns `Float::nan()` if the
-            /// number is `Float::nan()`.
-            #[inline]
-            fn abs(self) -> $T {
-                unsafe { $fabs(self) }
-            }
-
-            /// # Returns
-            ///
-            /// - `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()`
-            #[inline]
-            fn signum(self) -> $T {
-                if self.is_nan() {
-                    Float::nan()
-                } else {
-                    unsafe { $fcopysign(1.0, self) }
-                }
-            }
-
-            /// Returns `true` if the number is positive, including `+0.0` and
-            /// `Float::infinity()`.
-            #[inline]
-            fn is_positive(self) -> bool {
-                self > 0.0 || (1.0 / self) == Float::infinity()
-            }
-
-            /// Returns `true` if the number is negative, including `-0.0` and
-            /// `Float::neg_infinity()`.
-            #[inline]
-            fn is_negative(self) -> bool {
-                self < 0.0 || (1.0 / self) == Float::neg_infinity()
-            }
-        }
-    };
-}
-
-signed_float_impl!(f32,
-    intrinsics::fabsf32,
-    intrinsics::copysignf32)
-
-signed_float_impl!(f64,
-    intrinsics::fabsf64,
-    intrinsics::copysignf64)
-
 /// Raises a `base` to the power of `exp`, using exponentiation by squaring.
 ///
 /// # Example
@@ -702,6 +595,63 @@ int_impl!(int = i64, u64, 64,
     intrinsics::i64_sub_with_overflow,
     intrinsics::i64_mul_with_overflow)
 
+/// A built-in two's complement integer.
+pub trait SignedInt
+    : Int
+    + Neg<Self>
+{
+    /// Computes the absolute value of `self`. `Int::min_value()` will be
+    /// returned if the number is `Int::min_value()`.
+    fn abs(self) -> Self;
+
+    /// Returns a number representing sign of `self`.
+    ///
+    /// - `0` if the number is zero
+    /// - `1` if the number is positive
+    /// - `-1` if the number is negative
+    fn signum(self) -> Self;
+
+    /// Returns `true` if `self` is positive and `false` if the number
+    /// is zero or negative.
+    fn is_positive(self) -> bool;
+
+    /// Returns `true` if `self` is negative and `false` if the number
+    /// is zero or positive.
+    fn is_negative(self) -> bool;
+}
+
+macro_rules! signed_int_impl {
+    ($T:ty) => {
+        impl SignedInt for $T {
+            #[inline]
+            fn abs(self) -> $T {
+                if self.is_negative() { -self } else { self }
+            }
+
+            #[inline]
+            fn signum(self) -> $T {
+                match self {
+                    n if n > 0 =>  1,
+                    0          =>  0,
+                    _          => -1,
+                }
+            }
+
+            #[inline]
+            fn is_positive(self) -> bool { self > 0 }
+
+            #[inline]
+            fn is_negative(self) -> bool { self < 0 }
+        }
+    }
+}
+
+signed_int_impl!(i8)
+signed_int_impl!(i16)
+signed_int_impl!(i32)
+signed_int_impl!(i64)
+signed_int_impl!(int)
+
 /// A built-in unsigned integer.
 pub trait UnsignedInt: Int {
     /// Returns `true` iff `self == 2^k` for some `k`.
@@ -1257,7 +1207,7 @@ pub trait Float
     + NumCast
     + PartialOrd
     + PartialEq
-    + Signed
+    + Neg<Self>
     + Add<Self,Self>
     + Sub<Self,Self>
     + Mul<Self,Self>
@@ -1327,6 +1277,22 @@ pub trait Float
     /// Return the fractional part of a number.
     fn fract(self) -> Self;
 
+    /// Computes the absolute value of `self`. Returns `Float::nan()` if the
+    /// number is `Float::nan()`.
+    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()`
+    fn signum(self) -> Self;
+    /// Returns `true` if `self` is positive, including `+0.0` and
+    /// `Float::infinity()`.
+    fn is_positive(self) -> bool;
+    /// Returns `true` if `self` is negative, including `-0.0` and
+    /// `Float::neg_infinity()`.
+    fn is_negative(self) -> bool;
+
     /// Fused multiply-add. Computes `(self * a) + b` with only one rounding
     /// error. This produces a more accurate result with better performance than
     /// a separate multiplication operation followed by an add.
@@ -1494,14 +1460,6 @@ one_impl!(i64, 1i64)
 one_impl!(f32, 1.0f32)
 one_impl!(f64, 1.0f64)
 
-#[deprecated = "Use `Signed::abs`"]
-pub fn abs<T: Signed>(value: T) -> T {
-    value.abs()
-}
-#[deprecated = "Use `Signed::signum`"]
-pub fn signum<T: Signed>(value: T) -> T {
-    value.signum()
-}
 #[deprecated = "Use `UnsignedInt::next_power_of_two`"]
 pub fn next_power_of_two<T: UnsignedInt>(n: T) -> T {
     n.next_power_of_two()