Sync to vitaut/zmij@f5c3426

Author: dtolnay

README.md

@@ -11,7 +11,7 @@ numbers to decimal strings.
 This Rust implementation is a line-by-line port of Victor Zverovich's
 implementation in C++, [https://github.com/vitaut/zmij][upstream].
 
-[upstream]: https://github.com/vitaut/zmij/tree/9a433c4bed034447c051e16b405ebc43cae05957
+[upstream]: https://github.com/vitaut/zmij/tree/f5c342697455b3a443ad4f331e35f4d74a7420b6
 
 ## Example
 

src/lib.rs

@@ -68,6 +68,8 @@ mod traits;
 #[cfg(not(zmij_no_select_unpredictable))]
 use core::hint;
 use core::mem::{self, MaybeUninit};
+#[cfg(test)]
+use core::ops::Index;
 use core::ptr;
 use core::slice;
 use core::str;
@@ -170,9 +172,27 @@ impl FloatTraits for f64 {
     }
 }
 
+struct Pow10SignificandsTable([(u64, u64); 617]);
+
+impl Pow10SignificandsTable {
+    unsafe fn get_unchecked(&self, dec_exp: i32) -> &(u64, u64) {
+        const DEC_EXP_MIN: i32 = -292;
+        unsafe { self.0.get_unchecked((dec_exp - DEC_EXP_MIN) as usize) }
+    }
+}
+
+#[cfg(test)]
+impl Index<i32> for Pow10SignificandsTable {
+    type Output = (u64, u64);
+    fn index(&self, dec_exp: i32) -> &Self::Output {
+        const DEC_EXP_MIN: i32 = -292;
+        &self.0[(dec_exp - DEC_EXP_MIN) as usize]
+    }
+}
+
 // 128-bit significands of powers of 10 rounded down.
 // Generated using 192-bit arithmetic method by Dougall Johnson.
-static POW10_SIGNIFICANDS: [(u64, u64); 617] = {
+static POW10_SIGNIFICANDS: Pow10SignificandsTable = {
     let mut data = [(0, 0); 617];
 
     struct uint192 {
@@ -218,11 +238,9 @@ static POW10_SIGNIFICANDS: [(u64, u64); 617] = {
         i += 1;
     }
 
-    data
+    Pow10SignificandsTable(data)
 };
 
-const DEC_EXP_MIN: i32 = -292;
-
 #[cfg_attr(feature = "no-panic", no_panic)]
 fn count_trailing_nonzeros(x: u64) -> usize {
     // We count the number of bytes until there are only zeros left.
@@ -537,8 +555,7 @@ where
     let num_bits = mem::size_of::<UInt>() as i32 * 8;
     if regular && !subnormal {
         let exp_shift = compute_exp_shift(bin_exp, dec_exp);
-        let (pow10_hi, pow10_lo) =
-            *unsafe { POW10_SIGNIFICANDS.get_unchecked((-dec_exp - DEC_EXP_MIN) as usize) };
+        let (pow10_hi, pow10_lo) = *unsafe { POW10_SIGNIFICANDS.get_unchecked(-dec_exp) };
 
         let integral; // integral part of bin_sig * pow10
         let fractional; // fractional part of bin_sig * pow10
@@ -608,8 +625,7 @@ where
 
     dec_exp = compute_dec_exp(bin_exp, regular);
     let exp_shift = compute_exp_shift(bin_exp, dec_exp);
-    let (mut pow10_hi, mut pow10_lo) =
-        *unsafe { POW10_SIGNIFICANDS.get_unchecked((-dec_exp - DEC_EXP_MIN) as usize) };
+    let (mut pow10_hi, mut pow10_lo) = *unsafe { POW10_SIGNIFICANDS.get_unchecked(-dec_exp) };
 
     // Fallback to Schubfach to guarantee correctness in boundary cases. This
     // requires switching to strict overestimates of powers of 10.

src/tests.rs

@@ -25,7 +25,7 @@ fn utilities() {
 
 #[test]
 fn umul_upper_inexact_to_odd() {
-    let (hi, lo) = crate::POW10_SIGNIFICANDS[0];
+    let (hi, lo) = crate::POW10_SIGNIFICANDS[-292];
     assert_eq!(
         crate::umul_upper_inexact_to_odd(hi, lo, 0x1234567890abcdefu64 << 1),
         0x24554a3ce60a45f5,
@@ -38,6 +38,8 @@ fn umul_upper_inexact_to_odd() {
 
 #[test]
 fn pow10() {
+    const DEC_EXP_MIN: i32 = -292;
+
     // Range of decimal exponents [K_min, K_max] from the paper.
     let dec_exp_min = -324_i32;
     let dec_exp_max = 292_i32;
@@ -59,6 +61,6 @@ fn pow10() {
         };
         let hi = u64::try_from(&result >> 64).unwrap();
         let lo = u64::try_from(result & (Uint::from(2_u8).pow(64) - Uint::from(1_u8))).unwrap();
-        assert_eq!((hi, lo), crate::POW10_SIGNIFICANDS[i]);
+        assert_eq!(crate::POW10_SIGNIFICANDS[DEC_EXP_MIN + i as i32], (hi, lo));
     }
 }