Correctly rounded floating point div_euclid.

library/std/benches/f128/mod.rs

@@ -0,0 +1,18 @@
+use core::f128::consts::PI;
+
+use test::{Bencher, black_box};
+
+#[bench]
+fn div_euclid_small(b: &mut Bencher) {
+    b.iter(|| black_box(10000.12345f128).div_euclid(black_box(PI)));
+}
+
+#[bench]
+fn div_euclid_medium(b: &mut Bencher) {
+    b.iter(|| black_box(1.123e30f128).div_euclid(black_box(PI)));
+}
+
+#[bench]
+fn div_euclid_large(b: &mut Bencher) {
+    b.iter(|| black_box(1.123e4000f128).div_euclid(black_box(PI)));
+}

library/std/benches/f16/mod.rs

@@ -0,0 +1,13 @@
+use core::f16::consts::PI;
+
+use test::{Bencher, black_box};
+
+#[bench]
+fn div_euclid_small(b: &mut Bencher) {
+    b.iter(|| black_box(20.12f16).div_euclid(black_box(PI)));
+}
+
+#[bench]
+fn div_euclid_large(b: &mut Bencher) {
+    b.iter(|| black_box(50000.0f16).div_euclid(black_box(PI)));
+}

library/std/benches/f32/mod.rs

@@ -0,0 +1,18 @@
+use core::f32::consts::PI;
+
+use test::{Bencher, black_box};
+
+#[bench]
+fn div_euclid_small(b: &mut Bencher) {
+    b.iter(|| black_box(130.12345f32).div_euclid(black_box(PI)));
+}
+
+#[bench]
+fn div_euclid_medium(b: &mut Bencher) {
+    b.iter(|| black_box(1.123e7f32).div_euclid(black_box(PI)));
+}
+
+#[bench]
+fn div_euclid_large(b: &mut Bencher) {
+    b.iter(|| black_box(1.123e32f32).div_euclid(black_box(PI)));
+}

library/std/benches/f64/mod.rs

@@ -0,0 +1,18 @@
+use core::f64::consts::PI;
+
+use test::{Bencher, black_box};
+
+#[bench]
+fn div_euclid_small(b: &mut Bencher) {
+    b.iter(|| black_box(1234.1234578f64).div_euclid(black_box(PI)));
+}
+
+#[bench]
+fn div_euclid_medium(b: &mut Bencher) {
+    b.iter(|| black_box(1.123e15f64).div_euclid(black_box(PI)));
+}
+
+#[bench]
+fn div_euclid_large(b: &mut Bencher) {
+    b.iter(|| black_box(1.123e300f64).div_euclid(black_box(PI)));
+}

library/std/benches/lib.rs

@@ -1,7 +1,13 @@
 // Disabling in Miri as these would take too long.
 #![cfg(not(miri))]
 #![feature(test)]
+#![feature(f16)]
+#![feature(f128)]
 
 extern crate test;
 
+mod f128;
+mod f16;
+mod f32;
+mod f64;
 mod hash;

library/std/src/f128.rs

@@ -4,6 +4,8 @@
 //!
 //! Mathematically significant numbers are provided in the `consts` sub-module.
 
+mod soft;
+
 #[cfg(test)]
 mod tests;
 
@@ -235,10 +237,14 @@ impl f128 {
 
     /// Calculates Euclidean division, the matching method for `rem_euclid`.
     ///
-    /// This computes the integer `n` such that
+    /// In infinite precision this computes the integer `n` such that
     /// `self = n * rhs + self.rem_euclid(rhs)`.
-    /// In other words, the result is `self / rhs` rounded to the integer `n`
-    /// such that `self >= n * rhs`.
+    /// In other words, the result is `self / rhs` rounded to the
+    /// integer `n` such that `self >= n * rhs`.
+    ///
+    /// However, due to a floating point round-off error the result can be rounded if
+    /// `self` is much larger in magnitude than `rhs`, such that `n` can't be represented
+    /// exactly.
     ///
     /// # Precision
     ///
@@ -264,29 +270,23 @@ impl f128 {
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
     pub fn div_euclid(self, rhs: f128) -> f128 {
-        let q = (self / rhs).trunc();
-        if self % rhs < 0.0 {
-            return if rhs > 0.0 { q - 1.0 } else { q + 1.0 };
-        }
-        q
+        soft::div_euclid(self, rhs)
     }
 
     /// Calculates the least nonnegative remainder of `self (mod rhs)`.
     ///
-    /// In particular, the return value `r` satisfies `0.0 <= r < rhs.abs()` in
-    /// most cases. However, due to a floating point round-off error it can
-    /// result in `r == rhs.abs()`, violating the mathematical definition, if
-    /// `self` is much smaller than `rhs.abs()` in magnitude and `self < 0.0`.
-    /// This result is not an element of the function's codomain, but it is the
-    /// closest floating point number in the real numbers and thus fulfills the
-    /// property `self == self.div_euclid(rhs) * rhs + self.rem_euclid(rhs)`
-    /// approximately.
+    /// In infinite precision the return value `r` satisfies `0 <= r < rhs.abs()`.
+    ///
+    /// However, due to a floating point round-off error the result can round to
+    /// `rhs.abs()` if `self` is much smaller than `rhs.abs()` in magnitude and `self < 0.0`.
     ///
     /// # Precision
     ///
     /// The result of this operation is guaranteed to be the rounded
     /// infinite-precision result.
     ///
+    /// The result is precise when `self >= 0.0`.
+    ///
     /// # Examples
     ///
     /// ```