---

yaml
---
r: 56527
b: refs/heads/auto
c: cdf4d4b
h: refs/heads/master
i:
  56525: d99f401
  56523: 525fb25
  56519: dcd6379
  56511: 2a461b6
v: v3

Author: jbclements

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 8f63f9789b12a69723630ae072b6ba63203ed0f6
+refs/heads/auto: cdf4d4bcddc7331239237ff9a667c724836ac4fa
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/libcore/core.rc

@@ -104,9 +104,8 @@ pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
 pub use iter::{ExtendedMutableIter};
 
 pub use num::{Num, NumCast};
-pub use num::{Orderable, Signed, Unsigned, Round};
-pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};
-pub use num::{Integer, Fractional, Real, RealExt};
+pub use num::{Orderable, Signed, Unsigned, Integer};
+pub use num::{Round, Fractional, Real, RealExt};
 pub use num::{Bitwise, BitCount, Bounded};
 pub use num::{Primitive, Int, Float};
 

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

@@ -11,6 +11,7 @@
 //! Operations and constants for `f32`
 
 use from_str;
+use libc::c_int;
 use num::{Zero, One, strconv};
 use prelude::*;
 
@@ -101,8 +102,8 @@ delegate!(
     fn sinh(n: c_float) -> c_float = c_float_utils::sinh,
     fn tan(n: c_float) -> c_float = c_float_utils::tan,
     fn tanh(n: c_float) -> c_float = c_float_utils::tanh,
-    fn tgamma(n: c_float) -> c_float = c_float_utils::tgamma
-)
+    fn tgamma(n: c_float) -> c_float = c_float_utils::tgamma)
+
 
 // These are not defined inside consts:: for consistency with
 // the integer types
@@ -367,153 +368,154 @@ impl Fractional for f32 {
     fn recip(&self) -> f32 { 1.0 / *self }
 }
 
-impl Algebraic for f32 {
+impl Real for f32 {
+    /// Archimedes' constant
     #[inline(always)]
-    fn pow(&self, n: f32) -> f32 { pow(*self, n) }
+    fn pi() -> f32 { 3.14159265358979323846264338327950288 }
 
+    /// 2.0 * pi
     #[inline(always)]
-    fn sqrt(&self) -> f32 { sqrt(*self) }
+    fn two_pi() -> f32 { 6.28318530717958647692528676655900576 }
 
+    /// pi / 2.0
     #[inline(always)]
-    fn rsqrt(&self) -> f32 { self.sqrt().recip() }
+    fn frac_pi_2() -> f32 { 1.57079632679489661923132169163975144 }
 
+    /// pi / 3.0
     #[inline(always)]
-    fn cbrt(&self) -> f32 { cbrt(*self) }
+    fn frac_pi_3() -> f32 { 1.04719755119659774615421446109316763 }
 
+    /// pi / 4.0
     #[inline(always)]
-    fn hypot(&self, other: f32) -> f32 { hypot(*self, other) }
-}
+    fn frac_pi_4() -> f32 { 0.785398163397448309615660845819875721 }
 
-impl Trigonometric for f32 {
+    /// pi / 6.0
     #[inline(always)]
-    fn sin(&self) -> f32 { sin(*self) }
+    fn frac_pi_6() -> f32 { 0.52359877559829887307710723054658381 }
 
+    /// pi / 8.0
     #[inline(always)]
-    fn cos(&self) -> f32 { cos(*self) }
+    fn frac_pi_8() -> f32 { 0.39269908169872415480783042290993786 }
 
+    /// 1 .0/ pi
     #[inline(always)]
-    fn tan(&self) -> f32 { tan(*self) }
+    fn frac_1_pi() -> f32 { 0.318309886183790671537767526745028724 }
 
+    /// 2.0 / pi
     #[inline(always)]
-    fn asin(&self) -> f32 { asin(*self) }
+    fn frac_2_pi() -> f32 { 0.636619772367581343075535053490057448 }
 
+    /// 2.0 / sqrt(pi)
     #[inline(always)]
-    fn acos(&self) -> f32 { acos(*self) }
+    fn frac_2_sqrtpi() -> f32 { 1.12837916709551257389615890312154517 }
 
+    /// sqrt(2.0)
     #[inline(always)]
-    fn atan(&self) -> f32 { atan(*self) }
+    fn sqrt2() -> f32 { 1.41421356237309504880168872420969808 }
 
+    /// 1.0 / sqrt(2.0)
     #[inline(always)]
-    fn atan2(&self, other: f32) -> f32 { atan2(*self, other) }
-}
+    fn frac_1_sqrt2() -> f32 { 0.707106781186547524400844362104849039 }
 
-impl Exponential for f32 {
+    /// Euler's number
     #[inline(always)]
-    fn exp(&self) -> f32 { exp(*self) }
+    fn e() -> f32 { 2.71828182845904523536028747135266250 }
 
+    /// log2(e)
     #[inline(always)]
-    fn exp2(&self) -> f32 { exp2(*self) }
+    fn log2_e() -> f32 { 1.44269504088896340735992468100189214 }
 
+    /// log10(e)
     #[inline(always)]
-    fn expm1(&self) -> f32 { expm1(*self) }
+    fn log10_e() -> f32 { 0.434294481903251827651128918916605082 }
 
+    /// log(2.0)
     #[inline(always)]
-    fn log(&self) -> f32 { ln(*self) }
+    fn log_2() -> f32 { 0.693147180559945309417232121458176568 }
 
+    /// log(10.0)
     #[inline(always)]
-    fn log2(&self) -> f32 { log2(*self) }
+    fn log_10() -> f32 { 2.30258509299404568401799145468436421 }
 
     #[inline(always)]
-    fn log10(&self) -> f32 { log10(*self) }
-}
+    fn pow(&self, n: f32) -> f32 { pow(*self, n) }
 
-impl Hyperbolic for f32 {
     #[inline(always)]
-    fn sinh(&self) -> f32 { sinh(*self) }
+    fn exp(&self) -> f32 { exp(*self) }
 
     #[inline(always)]
-    fn cosh(&self) -> f32 { cosh(*self) }
+    fn exp2(&self) -> f32 { exp2(*self) }
 
     #[inline(always)]
-    fn tanh(&self) -> f32 { tanh(*self) }
-}
+    fn expm1(&self) -> f32 { expm1(*self) }
 
-impl Real for f32 {
-    /// Archimedes' constant
     #[inline(always)]
-    fn pi() -> f32 { 3.14159265358979323846264338327950288 }
+    fn ldexp(&self, n: int) -> f32 { ldexp(*self, n as c_int) }
 
-    /// 2.0 * pi
     #[inline(always)]
-    fn two_pi() -> f32 { 6.28318530717958647692528676655900576 }
+    fn log(&self) -> f32 { ln(*self) }
 
-    /// pi / 2.0
     #[inline(always)]
-    fn frac_pi_2() -> f32 { 1.57079632679489661923132169163975144 }
+    fn log2(&self) -> f32 { log2(*self) }
 
-    /// pi / 3.0
     #[inline(always)]
-    fn frac_pi_3() -> f32 { 1.04719755119659774615421446109316763 }
+    fn log10(&self) -> f32 { log10(*self) }
 
-    /// pi / 4.0
     #[inline(always)]
-    fn frac_pi_4() -> f32 { 0.785398163397448309615660845819875721 }
+    fn log_radix(&self) -> f32 { log_radix(*self) as f32 }
 
-    /// pi / 6.0
     #[inline(always)]
-    fn frac_pi_6() -> f32 { 0.52359877559829887307710723054658381 }
+    fn ilog_radix(&self) -> int { ilog_radix(*self) as int }
 
-    /// pi / 8.0
     #[inline(always)]
-    fn frac_pi_8() -> f32 { 0.39269908169872415480783042290993786 }
+    fn sqrt(&self) -> f32 { sqrt(*self) }
 
-    /// 1 .0/ pi
     #[inline(always)]
-    fn frac_1_pi() -> f32 { 0.318309886183790671537767526745028724 }
+    fn rsqrt(&self) -> f32 { self.sqrt().recip() }
 
-    /// 2.0 / pi
     #[inline(always)]
-    fn frac_2_pi() -> f32 { 0.636619772367581343075535053490057448 }
+    fn cbrt(&self) -> f32 { cbrt(*self) }
 
-    /// 2.0 / sqrt(pi)
+    /// Converts to degrees, assuming the number is in radians
     #[inline(always)]
-    fn frac_2_sqrtpi() -> f32 { 1.12837916709551257389615890312154517 }
+    fn to_degrees(&self) -> f32 { *self * (180.0 / Real::pi::<f32>()) }
 
-    /// sqrt(2.0)
+    /// Converts to radians, assuming the number is in degrees
     #[inline(always)]
-    fn sqrt2() -> f32 { 1.41421356237309504880168872420969808 }
+    fn to_radians(&self) -> f32 { *self * (Real::pi::<f32>() / 180.0) }
 
-    /// 1.0 / sqrt(2.0)
     #[inline(always)]
-    fn frac_1_sqrt2() -> f32 { 0.707106781186547524400844362104849039 }
+    fn hypot(&self, other: f32) -> f32 { hypot(*self, other) }
 
-    /// Euler's number
     #[inline(always)]
-    fn e() -> f32 { 2.71828182845904523536028747135266250 }
+    fn sin(&self) -> f32 { sin(*self) }
 
-    /// log2(e)
     #[inline(always)]
-    fn log2_e() -> f32 { 1.44269504088896340735992468100189214 }
+    fn cos(&self) -> f32 { cos(*self) }
 
-    /// log10(e)
     #[inline(always)]
-    fn log10_e() -> f32 { 0.434294481903251827651128918916605082 }
+    fn tan(&self) -> f32 { tan(*self) }
 
-    /// log(2.0)
     #[inline(always)]
-    fn log_2() -> f32 { 0.693147180559945309417232121458176568 }
+    fn asin(&self) -> f32 { asin(*self) }
 
-    /// log(10.0)
     #[inline(always)]
-    fn log_10() -> f32 { 2.30258509299404568401799145468436421 }
+    fn acos(&self) -> f32 { acos(*self) }
 
-    /// Converts to degrees, assuming the number is in radians
     #[inline(always)]
-    fn to_degrees(&self) -> f32 { *self * (180.0 / Real::pi::<f32>()) }
+    fn atan(&self) -> f32 { atan(*self) }
 
-    /// Converts to radians, assuming the number is in degrees
     #[inline(always)]
-    fn to_radians(&self) -> f32 { *self * (Real::pi::<f32>() / 180.0) }
+    fn atan2(&self, other: f32) -> f32 { atan2(*self, other) }
+
+    #[inline(always)]
+    fn sinh(&self) -> f32 { sinh(*self) }
+
+    #[inline(always)]
+    fn cosh(&self) -> f32 { cosh(*self) }
+
+    #[inline(always)]
+    fn tanh(&self) -> f32 { tanh(*self) }
 }
 
 impl Bounded for f32 {