Cleanup

Author: tgross35

crates/libm-test/src/gen/domain.rs

@@ -162,6 +162,7 @@ impl<F> FloatExt for F where F: Float {}
 pub trait FloatExt: Float {
     const TINY_BITS: Self::Int = Self::Int::ONE;
 
+    /// Increment by one ULP, saturating at infinity.
     fn next_up(self) -> Self {
         let bits = self.to_bits();
         if self.is_nan() || bits == Self::INFINITY.to_bits() {
@@ -182,6 +183,7 @@ pub trait FloatExt: Float {
         Self::from_bits(next_bits)
     }
 
+    /// A faster version of `next_up` when skipping a specified number of bits.
     fn n_up(self, n: Self::Int) -> Self {
         let bits = self.to_bits();
         if self.is_nan() || bits == Self::INFINITY.to_bits() || n == Self::Int::ZERO {
@@ -194,16 +196,13 @@ pub trait FloatExt: Float {
         let inf_bits = Self::INFINITY.to_bits();
         let ninf_bits = Self::NEG_INFINITY.to_bits();
 
-        dbg!("up", self, n, crosses_zero, is_positive, inf_bits);
-
         let next_bits = if abs == Self::Int::ZERO {
             min(n, inf_bits)
         } else if crosses_zero {
-            let off = n - abs;
-            if off > inf_bits { inf_bits } else { off }
+            min(n - abs, inf_bits)
         } else if is_positive {
             // Positive, counting up is more positive but this may overflow
-            match dbg!(bits.checked_add(n)) {
+            match bits.checked_add(n) {
                 Some(v) if v >= inf_bits => inf_bits,
                 Some(v) => v,
                 None => inf_bits,
@@ -215,6 +214,7 @@ pub trait FloatExt: Float {
         Self::from_bits(next_bits)
     }
 
+    /// Decrement by one ULP, saturating at negative infinity.
     fn next_down(self) -> Self {
         let bits = self.to_bits();
         if self.is_nan() || bits == Self::NEG_INFINITY.to_bits() {
@@ -235,6 +235,7 @@ pub trait FloatExt: Float {
         Self::from_bits(next_bits)
     }
 
+    /// A faster version of `n_down` when skipping a specified number of bits.
     fn n_down(self, n: Self::Int) -> Self {
         let bits = self.to_bits();
         if self.is_nan() || bits == Self::NEG_INFINITY.to_bits() || n == Self::Int::ZERO {
@@ -247,21 +248,16 @@ pub trait FloatExt: Float {
         let inf_bits = Self::INFINITY.to_bits();
         let ninf_bits = Self::NEG_INFINITY.to_bits();
 
-        dbg!("down", self, n, crosses_zero);
-
         let next_bits = if abs == Self::Int::ZERO {
-            dbg!(min(n, inf_bits) | Self::SIGN_MASK)
+            min(n, inf_bits) | Self::SIGN_MASK
         } else if crosses_zero {
-            // dbg!(n - abs | Self::SIGN_MASK)
-            let off = n - abs;
-            let off = if off > inf_bits { inf_bits } else { off };
-            off | Self::SIGN_MASK
+            min(n - abs, inf_bits) | Self::SIGN_MASK
         } else if is_positive {
             // Positive, counting down is more negative
             bits - n
         } else {
             // Negative, counting up is more negative but this may overflow
-            match dbg!(bits.checked_add(n)) {
+            match bits.checked_add(n) {
                 Some(v) if v > ninf_bits => ninf_bits,
                 Some(v) => v,
                 None => ninf_bits,
@@ -273,7 +269,6 @@ pub trait FloatExt: Float {
 
 #[cfg(test)]
 mod tests {
-
     use super::*;
     use crate::f8;
 
@@ -335,13 +330,11 @@ mod tests {
             let v = f8::ALL[i];
 
             for n in 0..(f8::ALL_LEN - 110) {
-                eprintln!("start");
                 let down = v.n_down(n as u8).to_bits();
                 let up = v.n_up(n as u8).to_bits();
 
                 if let Some(down_exp_idx) = i.checked_sub(n) {
                     // No overflow
-
                     let mut expected = f8::ALL[down_exp_idx].to_bits();
                     if n >= 1 {
                         let crossed = &f8::ALL[down_exp_idx..=i];
@@ -350,16 +343,13 @@ mod tests {
                         if crossed.iter().any(|f| f8::eq_repr(*f, f8::ZERO))
                             && crossed.iter().any(|f| f8::eq_repr(*f, f8::NEG_ZERO))
                         {
+                            // Saturate to -inf if we are out of values
                             match down_exp_idx.checked_sub(1) {
                                 Some(v) => expected = f8::ALL[v].to_bits(),
                                 None => expected = f8::NEG_INFINITY.to_bits(),
                             }
-
-                            // down_exp_idx -= 1;
                         }
                     }
-                    // dbg!(f8::ALL[down_exp_idx], down_exp_idx);
-
                     assert_eq!(down, expected, "{i} {n} n_down({v:#010b})");
                 } else {
                     // Overflow to -inf
@@ -368,7 +358,6 @@ mod tests {
 
                 let mut up_exp_idx = i + n;
                 if up_exp_idx < f8::ALL_LEN {
-                    dbg!(up_exp_idx);
                     // No overflow
                     if n >= 1 && up_exp_idx < f8::ALL_LEN {
                         let crossed = &f8::ALL[i..=up_exp_idx];
@@ -381,7 +370,6 @@ mod tests {
                         }
                     }
 
-                    dbg!(up_exp_idx);
                     let expected = if up_exp_idx >= f8::ALL_LEN {
                         f8::INFINITY.to_bits()
                     } else {
@@ -396,9 +384,4 @@ mod tests {
             }
         }
     }
-
-    // #[test]
-    // fn logspace_basic() {
-    //     let v: Vec<_> = logspace::<f8, domain::Unbounded>(f8::ZERO, f8::ONE, 10).collect();
-    // }
 }