RELEASES.md

Release 0.4.4 (2023-08-22)

• Implemented From<bool> for BigInt and BigUint.
• Implemented num_traits::Euclid and CheckedEuclid for BigInt and BigUint.
• Implemented ties-to-even for BigInt and BigUint::to_f32 and to_f64.
• Implemented num_traits::FromBytes and ToBytes for BigInt and BigUint.
• Limited pre-allocation from serde size hints against potential OOM.
• Miscellaneous other code cleanups and maintenance tasks.

Contributors: @AaronKutch, @archseer, @cuviper, @dramforever, @icecream17, @icedrocket, @janmarthedal, @jaybosamiya, @OliveIsAWord, @PatrickNorton, @smoelius, @waywardmonkeys

Release 0.4.3 (2021-11-02)

• GHSA-v935-pqmr-g8v9: Fix unexpected panics in multiplication.

Contributors: @arvidn, @cuviper, @guidovranken

Release 0.4.2 (2021-09-03)

• Use explicit Integer::div_ceil to avoid the new unstable method.

Contributors: @catenacyber, @cuviper

Release 0.4.1 (2021-08-27)

• Fixed scalar divide-by-zero panics.
• Implemented DoubleEndedIterator for U32Digits and U64Digits.
• Optimized multiplication to avoid unnecessary allocations.
• Optimized string formatting for very large values.

Contributors: @cuviper, @PatrickNorton

Release 0.4.0 (2021-03-05)

Breaking Changes

• Updated public dependences on arbitrary, quickcheck, and rand:
  • arbitrary support has been updated to 1.0, requiring Rust 1.40.
  • quickcheck support has been updated to 1.0, requiring Rust 1.46.
  • rand support has been updated to 0.8, requiring Rust 1.36.
• Debug now shows plain numeric values for BigInt and BigUint, rather than the raw list of internal digits.

Contributors: @cuviper, @Gelbpunkt

Release 0.3.3 (2021-09-03)

• Use explicit Integer::div_ceil to avoid the new unstable method.

Contributors: @catenacyber, @cuviper

Release 0.3.2 (2021-03-04)

• The new BigUint methods count_ones and trailing_ones return the number of 1 bits in the entire value or just its least-significant tail, respectively.
• The new BigInt and BigUint methods bit and set_bit will read and write individual bits of the value. For negative BigInt, bits are determined as if they were in the two's complement representation.
• The from_radix_le and from_radix_be methods now accept empty buffers to represent zero.
• BigInt and BigUint can now iterate digits as u32 or u64, regardless of the actual internal digit size.

Contributors: @BartMassey, @cuviper, @janmarthedal, @sebastianv89, @Speedy37

Release 0.3.1 (2020-11-03)

• Addition and subtraction now uses intrinsics for performance on x86 and x86_64 when built with Rust 1.33 or later.
• Conversions to_f32 and to_f64 now return infinity for very large numbers, rather than None. This does preserve the sign too, so a large negative BigInt will convert to negative infinity.
• The optional arbitrary feature implements arbitrary::Arbitrary, distinct from quickcheck::Arbitrary.
• The division algorithm has been optimized to reduce the number of temporary allocations and improve the internal guesses at each step.
• BigInt and BigUint will opportunistically shrink capacity if the internal vector is much larger than needed.

Contributors: @cuviper, @e00E, @ejmahler, @notoria, @tczajka

Release 0.3.0 (2020-06-12)

Enhancements

• The internal BigDigit may now be either u32 or u64, although that implementation detail is not exposed in the API. For now, this is chosen to match the target pointer size, but may change in the future.
• No-std is now supported with the alloc crate on Rust 1.36.
• Pow is now implemented for bigint values, not just references.
• TryFrom is now implemented on Rust 1.34 and later, converting signed integers to unsigned, and narrowing big integers to primitives.
• Shl and Shr are now implemented for a variety of shift types.
• A new trailing_zeros() returns the number of consecutive zeros from the least significant bit.
• The new BigInt::magnitude and into_parts methods give access to its BigUint part as the magnitude.

Breaking Changes

• num-bigint now requires Rust 1.31 or greater.
  • The "i128" opt-in feature was removed, now always available.
• Updated public dependences:
  • rand support has been updated to 0.7, requiring Rust 1.32.
  • quickcheck support has been updated to 0.9, requiring Rust 1.34.
• Removed impl Neg for BigUint, which only ever panicked.
• Bit counts are now u64 instead of usize.

Contributors: @cuviper, @dignifiedquire, @hansihe, @kpcyrd, @milesand, @tech6hutch

Release 0.2.6 (2020-01-27)

• Fix the promotion of negative isize in BigInt assign-ops.

Contributors: @cuviper, @HactarCE

Release 0.2.5 (2020-01-09)

• Updated the autocfg build dependency to 1.0.

Contributors: @cuviper, @tspiteri

Release 0.2.4 (2020-01-01)

• The new BigUint::to_u32_digits method returns the number as a little-endian vector of base-2³² digits. The same method on BigInt also returns the sign.
• BigUint::modpow now applies a modulus even for exponent 1, which also affects BigInt::modpow.
• BigInt::modpow now returns the correct sign for negative bases with even exponents.

Contributors: @alex-ozdemir, @cuviper, @dingelish, @Speedy37, @youknowone

Release 0.2.3 (2019-09-03)

• Pow is now implemented for BigUint exponents.
• The optional quickcheck feature enables implementations of Arbitrary.
• See the full comparison for performance enhancements and more!

Contributors: @cuviper, @lcnr, @maxbla, @mikelodder7, @mikong, @TheLetterTheta, @tspiteri, @XAMPPRocky, @youknowone

Release 0.2.2 (2018-12-14)

• The Roots implementations now use better initial guesses.
• Fixed to_signed_bytes_* for some positive numbers, where the most-significant byte is 0x80 and the rest are 0.

Contributors: @cuviper, @leodasvacas

Release 0.2.1 (2018-11-02)

• RandBigInt now uses Rng::fill_bytes to improve performance, instead of repeated gen::<u32> calls. The also affects the implementations of the other rand traits. This may potentially change the values produced by some seeded RNGs on previous versions, but the values were tested to be stable with ChaChaRng, IsaacRng, and XorShiftRng.
• BigInt and BigUint now implement num_integer::Roots.
• BigInt and BigUint now implement num_traits::Pow.
• BigInt and BigUint now implement operators with 128-bit integers.

Contributors: @cuviper, @dignifiedquire, @mancabizjak, @Robbepop, @TheIronBorn, @thomwiggers

Release 0.2.0 (2018-05-25)

Enhancements

• BigInt and BigUint now implement Product and Sum for iterators of any item that we can Mul and Add, respectively. For example, a factorial can now be simply: let f: BigUint = (1u32..1000).product();
• BigInt now supports two's-complement logic operations, namely BitAnd, BitOr, BitXor, and Not. These act conceptually as if each number had an infinite prefix of 0 or 1 bits for positive or negative.
• BigInt now supports assignment operators like AddAssign.
• BigInt and BigUint now support conversions with i128 and u128, if sufficient compiler support is detected.
• BigInt and BigUint now implement rand's SampleUniform trait, and a custom RandomBits distribution samples by bit size.
• The release also includes other miscellaneous improvements to performance.

Breaking Changes

• num-bigint now requires rustc 1.15 or greater.
• The crate now has a std feature, and won't build without it. This is in preparation for someday supporting #![no_std] with alloc.
• The serde dependency has been updated to 1.0, still disabled by default. The rustc-serialize crate is no longer supported by num-bigint.
• The rand dependency has been updated to 0.5, now disabled by default. This requires rustc 1.22 or greater for rand's own requirement.
• Shr for BigInt now rounds down rather than toward zero, matching the behavior of the primitive integers for negative values.
• ParseBigIntError is now an opaque type.
• The big_digit module is no longer public, nor are the BigDigit and DoubleBigDigit types and ZERO_BIG_DIGIT constant that were re-exported in the crate root. Public APIs which deal in digits, like BigUint::from_slice, will now always be base-u32.

Contributors: @clarcharr, @cuviper, @dodomorandi, @tiehuis, @tspiteri

Release 0.1.44 (2018-05-14)

• Division with single-digit divisors is now much faster.
• The README now compares ramp, rug, rust-gmp, and apint.

Contributors: @cuviper, @Robbepop

Release 0.1.43 (2018-02-08)

• The new BigInt::modpow performs signed modular exponentiation, using the existing BigUint::modpow and rounding negatives similar to mod_floor.

Contributors: @cuviper

Release 0.1.42 (2018-02-07)

• num-bigint now has its own source repository at rust-num/num-bigint.
• lcm now avoids creating a large intermediate product.
• gcd now uses Stein's algorithm with faster shifts instead of division.
• rand support is now extended to 0.4 (while still allowing 0.3).

Contributors: @cuviper, @Emerentius, @ignatenkobrain, @mhogrefe

Prior releases

No prior release notes were kept. Thanks all the same to the many contributors that have made this crate what it is!