Vendor dependencies

notes-service/vendor/bigdecimal/src/impl_cmp.rs

@@ -0,0 +1,555 @@
+//! Implementation of comparison operations
+//!
+//! Comparisons between decimals and decimal refs
+//! are not directly supported as we lose some type
+//! inference features at the savings of a single
+//! '&' character.
+//!
+//! &BigDecimal and BigDecimalRef are comparable.
+//!
+
+use crate::*;
+
+use stdlib::cmp::Ordering;
+use stdlib::iter;
+
+impl PartialEq for BigDecimal {
+    fn eq(&self, rhs: &BigDecimal) -> bool {
+        self.to_ref() == rhs.to_ref()
+    }
+}
+
+impl<'rhs, T> PartialEq<T> for BigDecimalRef<'_>
+where
+    T: Into<BigDecimalRef<'rhs>> + Copy,
+{
+    fn eq(&self, rhs: &T) -> bool {
+        let rhs: BigDecimalRef<'rhs> = (*rhs).into();
+        check_equality_bigdecimal_ref(*self, rhs)
+    }
+}
+
+fn check_equality_bigdecimal_ref(lhs: BigDecimalRef, rhs: BigDecimalRef) -> bool {
+    match (lhs.sign(), rhs.sign()) {
+        // both zero
+        (Sign::NoSign, Sign::NoSign) => return true,
+        // signs are different
+        (a, b) if a != b => return false,
+        // signs are same, do nothing
+        _ => {}
+    }
+
+    let unscaled_int;
+    let scaled_int;
+    let trailing_zero_count;
+    match arithmetic::checked_diff(lhs.scale, rhs.scale) {
+        (Ordering::Equal, _) => {
+            return lhs.digits == rhs.digits;
+        }
+        (Ordering::Greater, Some(scale_diff)) => {
+            unscaled_int = lhs.digits;
+            scaled_int = rhs.digits;
+            trailing_zero_count = scale_diff;
+        }
+        (Ordering::Less, Some(scale_diff)) => {
+            unscaled_int = rhs.digits;
+            scaled_int = lhs.digits;
+            trailing_zero_count = scale_diff;
+        }
+        _ => {
+            // all other cases imply overflow in difference of scale,
+            // numbers must not be equal
+            return false;
+        }
+    }
+
+    debug_assert_ne!(trailing_zero_count, 0);
+
+    // test if unscaled_int is guaranteed to be less than
+    // scaled_int*10^trailing_zero_count based on highest bit
+    if highest_bit_lessthan_scaled(unscaled_int, scaled_int, trailing_zero_count) {
+        return false;
+    }
+
+    // try compare without allocating
+    if trailing_zero_count < 20 {
+        let pow = ten_to_the_u64(trailing_zero_count as u8);
+
+        let mut a_digits = unscaled_int.iter_u32_digits();
+        let mut b_digits = scaled_int.iter_u32_digits();
+
+        let mut carry = 0;
+        loop {
+            match (a_digits.next(), b_digits.next()) {
+                (Some(next_a), Some(next_b)) => {
+                    let wide_b = match (next_b as u64).checked_mul(pow) {
+                        Some(tmp) => tmp + carry,
+                        None => break,
+                    };
+
+                    let true_b = wide_b as u32;
+
+                    if next_a != true_b {
+                        return false;
+                    }
+
+                    carry = wide_b >> 32;
+                }
+                (None, Some(_)) => {
+                    return false;
+                }
+                (Some(a_digit), None) => {
+                    if a_digit != (carry as u32) {
+                        return false;
+                    }
+                    carry = 0;
+                }
+                (None, None) => {
+                    return carry == 0;
+                }
+            }
+        }
+
+        // we broke out of loop due to overflow - compare via allocation
+        let scaled_int = scaled_int * pow;
+        return &scaled_int == unscaled_int;
+    }
+
+    let trailing_zero_count = trailing_zero_count.to_usize().unwrap();
+    let unscaled_digits = unscaled_int.to_radix_le(10);
+
+    if trailing_zero_count > unscaled_digits.len() {
+        return false;
+    }
+
+    // split into digits below the other value, and digits overlapping
+    let (low_digits, overlap_digits) = unscaled_digits.split_at(trailing_zero_count);
+
+    // if any of the low digits are zero, they are not equal
+    if low_digits.iter().any(|&d| d != 0) {
+        return false;
+    }
+
+    let scaled_digits = scaled_int.to_radix_le(10);
+
+    // different lengths with trailing zeros
+    if overlap_digits.len() != scaled_digits.len() {
+        return false;
+    }
+
+    // return true if all digits are the same
+    overlap_digits.iter().zip(scaled_digits.iter()).all(|(digit_a, digit_b)| digit_a == digit_b)
+}
+
+
+impl PartialOrd for BigDecimal {
+    #[inline]
+    fn partial_cmp(&self, other: &BigDecimal) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl PartialOrd for BigDecimalRef<'_> {
+    fn partial_cmp(&self, other: &BigDecimalRef<'_>) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+
+impl Ord for BigDecimal {
+    #[inline]
+    fn cmp(&self, other: &BigDecimal) -> Ordering {
+        self.to_ref().cmp(&other.to_ref())
+    }
+}
+
+impl Ord for BigDecimalRef<'_> {
+    /// Complete ordering implementation for BigDecimal
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use std::str::FromStr;
+    ///
+    /// let a = bigdecimal::BigDecimal::from_str("-1").unwrap();
+    /// let b = bigdecimal::BigDecimal::from_str("1").unwrap();
+    /// assert!(a < b);
+    /// assert!(b > a);
+    /// let c = bigdecimal::BigDecimal::from_str("1").unwrap();
+    /// assert!(b >= c);
+    /// assert!(c >= b);
+    /// let d = bigdecimal::BigDecimal::from_str("10.0").unwrap();
+    /// assert!(d > c);
+    /// let e = bigdecimal::BigDecimal::from_str(".5").unwrap();
+    /// assert!(e < c);
+    /// ```
+    #[inline]
+    fn cmp(&self, other: &BigDecimalRef) -> Ordering {
+        use Ordering::*;
+
+        let scmp = self.sign().cmp(&other.sign());
+        if scmp != Ordering::Equal {
+            return scmp;
+        }
+
+        if self.sign() == Sign::NoSign {
+            return Ordering::Equal;
+        }
+
+        let result = match arithmetic::checked_diff(self.scale, other.scale) {
+            (Greater, Some(scale_diff)) | (Equal, Some(scale_diff)) => {
+                compare_scaled_biguints(self.digits, other.digits, scale_diff)
+            }
+            (Less, Some(scale_diff)) => {
+                compare_scaled_biguints(other.digits, self.digits, scale_diff).reverse()
+            }
+            (res, None) => {
+                // The difference in scale does not fit in a u64,
+                // we can safely assume the value of digits do not matter
+                // (unless we have a 2^64 (i.e. ~16 exabyte) long number
+
+                // larger scale means smaller number, reverse this ordering
+                res.reverse()
+            }
+        };
+
+        if other.sign == Sign::Minus {
+            result.reverse()
+        } else {
+            result
+        }
+    }
+}
+
+
+/// compare scaled uints: a <=> b * 10^{scale_diff}
+///
+fn compare_scaled_biguints(a: &BigUint, b: &BigUint, scale_diff: u64) -> Ordering {
+    use Ordering::*;
+
+    if scale_diff == 0 {
+        return a.cmp(b);
+    }
+
+    // check if highest bit of a is less than b * 10^scale_diff
+    if highest_bit_lessthan_scaled(a, b, scale_diff) {
+        return Ordering::Less;
+    }
+
+    // if biguints fit it u64 or u128, compare using those (avoiding allocations)
+    if let Some(result) = compare_scalar_biguints(a, b, scale_diff) {
+        return result;
+    }
+
+    let a_digit_count = count_decimal_digits_uint(a);
+    let b_digit_count = count_decimal_digits_uint(b);
+
+    let digit_count_cmp = a_digit_count.cmp(&(b_digit_count + scale_diff));
+    if digit_count_cmp != Equal {
+        return digit_count_cmp;
+    }
+
+    let a_digits = a.to_radix_le(10);
+    let b_digits = b.to_radix_le(10);
+
+    debug_assert_eq!(a_digits.len(), a_digit_count as usize);
+    debug_assert_eq!(b_digits.len(), b_digit_count as usize);
+
+    let mut a_it = a_digits.iter().rev();
+    let mut b_it = b_digits.iter().rev();
+
+    loop {
+        match (a_it.next(), b_it.next()) {
+            (Some(ai), Some(bi)) => {
+                match ai.cmp(bi) {
+                    Equal => continue,
+                    result => return result,
+                }
+            }
+            (Some(&ai), None) => {
+                if ai == 0 && a_it.all(Zero::is_zero) {
+                    return Equal;
+                } else {
+                    return Greater;
+                }
+            }
+            (None, Some(&bi)) => {
+                if bi == 0 && b_it.all(Zero::is_zero) {
+                    return Equal;
+                } else {
+                    return Less;
+                }
+            }
+            (None, None) => {
+                return Equal;
+            }
+        }
+    }
+}
+
+/// Try fitting biguints into primitive integers, using those for ordering if possible
+fn compare_scalar_biguints(a: &BigUint, b: &BigUint, scale_diff: u64) -> Option<Ordering> {
+    let scale_diff = scale_diff.to_usize()?;
+
+    // try u64, then u128
+    compare_scaled_uints::<u64>(a, b, scale_diff)
+    .or_else(|| compare_scaled_uints::<u128>(a, b, scale_diff))
+}
+
+/// Implementation comparing biguints cast to generic type
+fn compare_scaled_uints<'a, T>(
+    a: &'a BigUint,
+    b: &'a BigUint,
+    scale_diff: usize,
+) -> Option<Ordering>
+where
+    T: num_traits::PrimInt + TryFrom<&'a BigUint>,
+{
+    let ten = T::from(10).unwrap();
+
+    let a = T::try_from(a).ok();
+    let b = T::try_from(b).ok().and_then(
+                |b| num_traits::checked_pow(ten, scale_diff).and_then(
+                    |p| b.checked_mul(&p)));
+
+    match (a, b) {
+        (Some(a), Some(scaled_b)) => Some(a.cmp(&scaled_b)),
+        // if scaled_b doesn't fit in size T, while 'a' does, then a is certainly less
+        (Some(_), None) => Some(Ordering::Less),
+        // if a doesn't fit in size T, while 'scaled_b' does, then a is certainly greater
+        (None, Some(_)) => Some(Ordering::Greater),
+        // neither fits, cannot determine relative size
+        (None, None) => None,
+    }
+}
+
+/// Return highest_bit(a) < highest_bit(b * 10^{scale})
+///
+/// Used for optimization when comparing scaled integers
+///
+/// ```math
+/// a < b * 10^{scale}
+/// log(a) < log(b) + scale * log(10)
+/// ```
+///
+fn highest_bit_lessthan_scaled(a: &BigUint, b: &BigUint, scale: u64) -> bool {
+    let a_bits = a.bits();
+    let b_bits = b.bits();
+    if a_bits < b_bits {
+        return true;
+    }
+    let log_scale = LOG2_10 * scale as f64;
+    match b_bits.checked_add(log_scale as u64) {
+        Some(scaled_b_bit) => a_bits < scaled_b_bit,
+        None => true, // overflowing u64 means we are definitely bigger
+    }
+}
+
+macro_rules! impl_prim_cmp {
+    ($t:ty) => {
+        impl PartialOrd<$t> for BigDecimal {
+            fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
+                self.to_ref().partial_cmp(other)
+            }
+        }
+
+        impl PartialEq<$t> for BigDecimal {
+            fn eq(&self, rhs: &$t) -> bool {
+                self.to_ref().eq(rhs)
+            }
+        }
+
+        impl PartialOrd<$t> for &BigDecimal {
+            fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
+                self.to_ref().partial_cmp(other)
+            }
+        }
+
+        impl PartialOrd<$t> for BigDecimalRef<'_>
+        {
+            fn partial_cmp(&self, other: &$t) -> Option<Ordering> {
+                let rhs = BigDecimal::from(other);
+                self.partial_cmp(&rhs.to_ref())
+            }
+        }
+
+        impl PartialEq<$t> for &BigDecimal {
+            fn eq(&self, rhs: &$t) -> bool {
+                self.to_ref().eq(rhs)
+            }
+        }
+
+        impl PartialEq<$t> for BigDecimalRef<'_>
+        {
+            fn eq(&self, rhs: &$t) -> bool {
+                let rhs = BigDecimal::from(rhs);
+                check_equality_bigdecimal_ref(*self, rhs.to_ref())
+            }
+        }
+    };
+}
+
+impl_prim_cmp!(u8);
+impl_prim_cmp!(u16);
+impl_prim_cmp!(u32);
+impl_prim_cmp!(u64);
+impl_prim_cmp!(u128);
+impl_prim_cmp!(i8);
+impl_prim_cmp!(i16);
+impl_prim_cmp!(i32);
+impl_prim_cmp!(i64);
+impl_prim_cmp!(i128);
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    mod compare_scaled_biguints {
+        use super::*;
+
+        macro_rules! impl_test {
+            ($name:ident: $a:literal > $b:literal e $e:literal) => {
+                impl_test!($name: $a Greater $b e $e);
+            };
+            ($name:ident: $a:literal < $b:literal e $e:literal) => {
+                impl_test!($name: $a Less $b e $e);
+            };
+            ($name:ident: $a:literal = $b:literal e $e:literal) => {
+                impl_test!($name: $a Equal $b e $e);
+            };
+            ($name:ident: $a:literal $op:ident $b:literal e $e:literal) => {
+                #[test]
+                fn $name() {
+                    let a: BigUint = $a.parse().unwrap();
+                    let b: BigUint = $b.parse().unwrap();
+
+                    let result = compare_scaled_biguints(&a, &b, $e);
+                    assert_eq!(result, Ordering::$op);
+                }
+            };
+        }
+
+        impl_test!(case_500_51e1: "500" < "51" e 1);
+        impl_test!(case_500_44e1: "500" > "44" e 1);
+        impl_test!(case_5000_50e2: "5000" = "50" e 2);
+        impl_test!(case_1234e9_12345e9: "1234000000000" < "12345" e 9);
+        impl_test!(case_1116xx459_759xx717e2: "1116386634271380982470843247639640260491505327092723527088459" < "759522625769651746138617259189939751893902453291243506584717" e 2);
+    }
+
+    /// Test that large-magnitidue exponentials will not crash
+    #[test]
+    fn test_cmp_on_exp_boundaries() {
+        let a = BigDecimal::new(1.into(), i64::MAX);
+        let z = BigDecimal::new(1.into(), i64::MIN);
+        assert_ne!(a, z);
+        assert_ne!(z, a);
+
+        assert!(a < z);
+
+        assert_eq!(a, a);
+        assert_eq!(z, z);
+    }
+
+    mod ord {
+        use super::*;
+
+        macro_rules! impl_test {
+            ($name:ident: $a:literal < $b:literal) => {
+                #[test]
+                fn $name() {
+                    let a: BigDecimal = $a.parse().unwrap();
+                    let b: BigDecimal = $b.parse().unwrap();
+
+                    assert!(&a < &b);
+                    assert!(&b > &a);
+                    assert_ne!(a, b);
+                }
+            };
+        }
+
+        impl_test!(case_diff_signs: "-1" < "1");
+        impl_test!(case_n1_0: "-1" < "0");
+        impl_test!(case_0_1: "0" < "1");
+        impl_test!(case_1d2345_1d2346: "1.2345" < "1.2346");
+        impl_test!(case_compare_extreme: "1e-9223372036854775807" < "1");
+        impl_test!(case_compare_extremes: "1e-9223372036854775807" < "1e9223372036854775807");
+        impl_test!(case_small_difference: "472697816888807260.1604" < "472697816888807260.16040000000000000000001");
+        impl_test!(case_very_small_diff: "-1.0000000000000000000000000000000000000000000000000001" < "-1");
+
+        impl_test!(case_1_2p128: "1" < "340282366920938463463374607431768211455");
+        impl_test!(case_1_1e39: "1000000000000000000000000000000000000000" < "1e41");
+
+        impl_test!(case_1d414xxx573: "1.414213562373095048801688724209698078569671875376948073176679730000000000000000000000000000000000000" < "1.41421356237309504880168872420969807856967187537694807317667974000000000");
+        impl_test!(case_11d414xxx573: "1.414213562373095048801688724209698078569671875376948073176679730000000000000000000000000000000000000" < "11.41421356237309504880168872420969807856967187537694807317667974000000000");
+    }
+
+    mod eq {
+        use super::*;
+
+        macro_rules! impl_test {
+            ($name:ident: $a:literal = $b:literal) => {
+                #[test]
+                fn $name() {
+                    let a: BigDecimal = $a.parse().unwrap();
+                    let b: BigDecimal = $b.parse().unwrap();
+
+                    assert_eq!(&a, &b);
+                    assert_eq!(a, b);
+                }
+            };
+        }
+
+        impl_test!(case_zero: "0" = "0.00");
+        impl_test!(case_1_1d00: "1" = "1.00");
+        impl_test!(case_n1_n1000en3: "-1" = "-1000e-3");
+        impl_test!(case_0d000034500_345en7: "0.000034500" = "345e-7");
+    }
+
+    #[test]
+    fn test_borrow_neg_cmp() {
+        let x: BigDecimal = "1514932018891593.916341142773".parse().unwrap();
+        let y: BigDecimal = "1514932018891593916341142773e-12".parse().unwrap();
+
+        assert_eq!(x, y);
+
+        let x_ref = x.to_ref();
+        assert_eq!(x_ref, &y);
+        assert_ne!(x_ref.neg(), x_ref);
+        assert_eq!(x_ref.neg().neg(), x_ref);
+    }
+
+    mod cmp_prim {
+        use super::*;
+
+        #[test]
+        fn cmp_zero_u8() {
+            let n = BigDecimal::zero();
+            assert!(&n == 0u8);
+        }
+    }
+
+    #[cfg(property_tests)]
+    mod prop {
+        use super::*;
+        use proptest::prelude::*;
+
+        proptest! {
+            #![proptest_config(ProptestConfig { cases: 5000, ..Default::default() })]
+
+            #[test]
+            fn cmp_matches_f64(
+                f in proptest::num::f64::NORMAL | proptest::num::f64::SUBNORMAL | proptest::num::f64::ZERO,
+                g in proptest::num::f64::NORMAL | proptest::num::f64::SUBNORMAL | proptest::num::f64::ZERO
+            ) {
+                let a: BigDecimal = BigDecimal::from_f64(f).unwrap();
+                let b: BigDecimal = BigDecimal::from_f64(g).unwrap();
+
+                let expected = PartialOrd::partial_cmp(&f, &g).unwrap();
+                let value = a.cmp(&b);
+
+                prop_assert_eq!(expected, value)
+            }
+        }
+    }
+}