Merge #219

219: rust: use explicitily Integer::div_ceil r=cuviper a=catenacyber

Fixes #218

cf rust-lang/rust#88581

Co-authored-by: Philippe Antoine <contact@catenacyber.fr>
Co-authored-by: Josh Stone <cuviper@gmail.com>

Cargo.toml

@@ -8,7 +8,7 @@ categories = [ "algorithms", "data-structures", "science" ]
 license = "MIT OR Apache-2.0"
 name = "num-bigint"
 repository = "https://github.com/rust-num/num-bigint"
-version = "0.4.1"
+version = "0.4.2"
 readme = "README.md"
 build = "build.rs"
 exclude = ["/bors.toml", "/ci/*", "/.github/*"]

RELEASES.md

@@ -1,3 +1,11 @@
+# Release 0.4.2 (2021-09-03)
+
+- [Use explicit `Integer::div_ceil` to avoid the new unstable method.][219]
+
+**Contributors**: @catenacyber, @cuviper
+
+[219]: https://github.com/rust-num/num-bigint/pull/219
+
 # Release 0.4.1 (2021-08-27)
 
 - [Fixed scalar divide-by-zero panics.][200]

src/bigrand.rs

@@ -66,7 +66,7 @@ impl<R: Rng + ?Sized> RandBigInt for R {
         let len = (digits + (rem > 0) as u64)
             .to_usize()
             .expect("capacity overflow");
-        let native_digits = bit_size.div_ceil(&64);
+        let native_digits = Integer::div_ceil(&bit_size, &64);
         let native_len = native_digits.to_usize().expect("capacity overflow");
         let mut data = vec![0u64; native_len];
         unsafe {

src/biguint.rs

@@ -395,7 +395,7 @@ impl Roots for BigUint {
                 // Try to guess by scaling down such that it does fit in `f64`.
                 // With some (x * 2ⁿᵏ), its nth root ≈ (ⁿ√x * 2ᵏ)
                 let extra_bits = bits - (core::f64::MAX_EXP as u64 - 1);
-                let root_scale = extra_bits.div_ceil(&n64);
+                let root_scale = Integer::div_ceil(&extra_bits, &n64);
                 let scale = root_scale * n64;
                 if scale < bits && bits - scale > n64 {
                     (self >> scale).nth_root(n) << root_scale

src/biguint/convert.rs

@@ -65,9 +65,8 @@ fn from_inexact_bitwise_digits_le(v: &[u8], bits: u8) -> BigUint {
     debug_assert!(!v.is_empty() && bits <= 8 && big_digit::BITS % bits != 0);
     debug_assert!(v.iter().all(|&c| BigDigit::from(c) < (1 << bits)));
 
-    let big_digits = (v.len() as u64)
-        .saturating_mul(bits.into())
-        .div_ceil(&big_digit::BITS.into())
+    let total_bits = (v.len() as u64).saturating_mul(bits.into());
+    let big_digits = Integer::div_ceil(&total_bits, &big_digit::BITS.into())
         .to_usize()
         .unwrap_or(core::usize::MAX);
     let mut data = Vec::with_capacity(big_digits);
@@ -580,9 +579,7 @@ pub(super) fn to_bitwise_digits_le(u: &BigUint, bits: u8) -> Vec<u8> {
     let last_i = u.data.len() - 1;
     let mask: BigDigit = (1 << bits) - 1;
     let digits_per_big_digit = big_digit::BITS / bits;
-    let digits = u
-        .bits()
-        .div_ceil(&u64::from(bits))
+    let digits = Integer::div_ceil(&u.bits(), &u64::from(bits))
         .to_usize()
         .unwrap_or(core::usize::MAX);
     let mut res = Vec::with_capacity(digits);
@@ -608,9 +605,7 @@ fn to_inexact_bitwise_digits_le(u: &BigUint, bits: u8) -> Vec<u8> {
     debug_assert!(!u.is_zero() && bits <= 8 && big_digit::BITS % bits != 0);
 
     let mask: BigDigit = (1 << bits) - 1;
-    let digits = u
-        .bits()
-        .div_ceil(&u64::from(bits))
+    let digits = Integer::div_ceil(&u.bits(), &u64::from(bits))
         .to_usize()
         .unwrap_or(core::usize::MAX);
     let mut res = Vec::with_capacity(digits);

src/biguint/serde.rs

@@ -89,7 +89,7 @@ impl<'de> Visitor<'de> for U32Visitor {
         use num_integer::Integer;
 
         let u32_len = seq.size_hint().unwrap_or(0);
-        let len = u32_len.div_ceil(&2);
+        let len = Integer::div_ceil(&u32_len, &2);
         let mut data = Vec::with_capacity(len);
 
         while let Some(lo) = seq.next_element::<u32>()? {