---

yaml
---
r: 56455
b: refs/heads/auto
c: b7cf89f
h: refs/heads/master
i:
  56453: 6357307
  56451: 8c93f73
  56447: 0e10a78
v: v3

Author: brendanzab

[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: 6cc7107aa6ca78093cb81aed44170099b8fad68a
+refs/heads/auto: b7cf89f6e8c076cfd844b884474279687554597e
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

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

@@ -543,6 +543,22 @@ impl Float for f32 {
     fn is_finite(&self) -> bool {
         !(self.is_NaN() || self.is_infinite())
     }
+
+    ///
+    /// 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.
+    ///
+    #[inline(always)]
+    fn mul_add(&self, a: f32, b: f32) -> f32 {
+        mul_add(*self, a, b)
+    }
+
+    /// Returns the next representable floating-point value in the direction of `other`
+    #[inline(always)]
+    fn next_after(&self, other: f32) -> f32 {
+        nextafter(*self, other)
+    }
 }
 
 //

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

@@ -583,6 +583,22 @@ impl Float for f64 {
     fn is_finite(&self) -> bool {
         !(self.is_NaN() || self.is_infinite())
     }
+
+    ///
+    /// 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.
+    ///
+    #[inline(always)]
+    fn mul_add(&self, a: f64, b: f64) -> f64 {
+        mul_add(*self, a, b)
+    }
+
+    /// Returns the next representable floating-point value in the direction of `other`
+    #[inline(always)]
+    fn next_after(&self, other: f64) -> f64 {
+        nextafter(*self, other)
+    }
 }
 
 //

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

@@ -735,6 +735,22 @@ impl Float for float {
     fn is_finite(&self) -> bool {
         !(self.is_NaN() || self.is_infinite())
     }
+
+    ///
+    /// 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.
+    ///
+    #[inline(always)]
+    fn mul_add(&self, a: float, b: float) -> float {
+        mul_add(*self as f64, a as f64, b as f64) as float
+    }
+
+    /// Returns the next representable floating-point value in the direction of `other`
+    #[inline(always)]
+    fn next_after(&self, other: float) -> float {
+        nextafter(*self as f64, other as f64) as float
+    }
 }
 
 #[cfg(test)]

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

@@ -105,6 +105,9 @@ pub trait Fractional: Num
     fn recip(&self) -> Self;
 }
 
+///
+/// Defines constants and methods common to real numbers
+///
 pub trait Real: Signed
               + Fractional {
     // FIXME (#5527): usages of `int` should be replaced with an associated
@@ -237,8 +240,7 @@ pub trait Int: Integer
              + BitCount {}
 
 ///
-/// Primitive floating point numbers. This trait should only be implemented
-/// for the `f32`, `f64`, and `float` types.
+/// Primitive floating point numbers
 ///
 pub trait Float: Real
                + Signed
@@ -252,6 +254,9 @@ pub trait Float: Real
     fn is_NaN(&self) -> bool;
     fn is_infinite(&self) -> bool;
     fn is_finite(&self) -> bool;
+
+    fn mul_add(&self, a: Self, b: Self) -> Self;
+    fn next_after(&self, other: Self) -> Self;
 }
 
 ///