Rustfmt + fix panic on long fractions

Author: dpbriggs

src/lib.rs

@@ -52,9 +52,9 @@ use std::default::Default;
 use std::error::Error;
 use std::fmt;
 use std::hash::{Hash, Hasher};
+use std::iter::Sum;
 use std::num::{ParseFloatError, ParseIntError};
 use std::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Rem, Sub, SubAssign};
-use std::iter::Sum;
 use std::str::{self, FromStr};
 
 use num_bigint::{BigInt, ParseBigIntError, Sign, ToBigInt};
@@ -127,11 +127,6 @@ fn get_rounding_term(num: &BigInt) -> u8 {
         }
         n *= 2;
     }
-
-    // string-method
-    // let s = format!("{}", num);
-    // let high_digit = u8::from_str(&s[0..1]).unwrap();
-    // if high_digit < 5 { 0 } else { 1 }
 }
 
 /// A big decimal type.
@@ -229,7 +224,7 @@ impl BigDecimal {
 
             // check for "leading zero" in remainder term; otherwise round
             if p < 10 * &r {
-              q += get_rounding_term(&r);
+                q += get_rounding_term(&r);
             }
 
             BigDecimal {
@@ -593,16 +588,16 @@ impl BigDecimal {
             return self.clone();
         }
 
-        let mut number = bigint.to_i128().unwrap();
-        if number < 0 {
+        let mut number = bigint.clone();
+        if number < BigInt::zero() {
             number = -number;
         }
         for _ in 0..(need_to_round_digits - 1) {
             number /= 10;
         }
         let digit = number % 10;
 
-        if digit <= 4 {
+        if digit <= BigInt::from(4) {
             self.with_scale(round_digits)
         } else if bigint.is_negative() {
             self.with_scale(round_digits) - BigDecimal::new(BigInt::from(1), round_digits)
@@ -619,7 +614,7 @@ impl BigDecimal {
         if self.scale <= 0 {
             true
         } else {
-           (self.int_val.clone() % ten_to_the(self.scale as u64)).is_zero()
+            (self.int_val.clone() % ten_to_the(self.scale as u64)).is_zero()
         }
     }
 
@@ -661,7 +656,7 @@ impl BigDecimal {
     #[must_use]
     pub fn normalized(&self) -> BigDecimal {
         if self == &BigDecimal::zero() {
-            return BigDecimal::zero()
+            return BigDecimal::zero();
         }
         let (sign, mut digits) = self.int_val.to_radix_be(10);
         let trailing_count = digits.iter().rev().take_while(|i| **i == 0).count();
@@ -729,7 +724,7 @@ impl FromStr for BigDecimal {
     }
 }
 
-#[allow(deprecated)]  // trim_right_match -> trim_end_match
+#[allow(deprecated)] // trim_right_match -> trim_end_match
 impl Hash for BigDecimal {
     fn hash<H: Hasher>(&self, state: &mut H) {
         let mut dec_str = self.int_val.to_str_radix(10).to_string();
@@ -1003,7 +998,8 @@ impl<'a> AddAssign<&'a BigInt> for BigDecimal {
         match self.scale.cmp(&0) {
             Ordering::Equal => self.int_val += rhs,
             Ordering::Greater => self.int_val += rhs * ten_to_the(self.scale as u64),
-            Ordering::Less =>  { // *self += BigDecimal::new(rhs, 0)
+            Ordering::Less => {
+                // *self += BigDecimal::new(rhs, 0)
                 self.int_val *= ten_to_the((-self.scale) as u64);
                 self.int_val += rhs;
                 self.scale = 0;
@@ -1164,7 +1160,9 @@ impl<'a> SubAssign<&'a BigInt> for BigDecimal {
     fn sub_assign(&mut self, rhs: &BigInt) {
         match self.scale.cmp(&0) {
             Ordering::Equal => SubAssign::sub_assign(&mut self.int_val, rhs),
-            Ordering::Greater => SubAssign::sub_assign(&mut self.int_val, rhs * ten_to_the(self.scale as u64)),
+            Ordering::Greater => {
+                SubAssign::sub_assign(&mut self.int_val, rhs * ten_to_the(self.scale as u64))
+            }
             Ordering::Less => {
                 self.int_val *= ten_to_the((-self.scale) as u64);
                 SubAssign::sub_assign(&mut self.int_val, rhs);
@@ -1255,8 +1253,6 @@ impl<'a, 'b> Mul<&'a BigInt> for &'b BigDecimal {
     }
 }
 
-
-
 forward_val_assignop!(impl MulAssign for BigDecimal, mul_assign);
 
 impl<'a> MulAssign<&'a BigDecimal> for BigDecimal {
@@ -1544,14 +1540,14 @@ impl Signed for BigDecimal {
 
 impl Sum for BigDecimal {
     #[inline]
-    fn sum<I: Iterator<Item=BigDecimal>>(iter: I) -> BigDecimal {
+    fn sum<I: Iterator<Item = BigDecimal>>(iter: I) -> BigDecimal {
         iter.fold(Zero::zero(), |a, b| a + b)
     }
 }
 
 impl<'a> Sum<&'a BigDecimal> for BigDecimal {
     #[inline]
-    fn sum<I: Iterator<Item=&'a BigDecimal>>(iter: I) -> BigDecimal {
+    fn sum<I: Iterator<Item = &'a BigDecimal>>(iter: I) -> BigDecimal {
         iter.fold(Zero::zero(), |a, b| a + b)
     }
 }
@@ -1892,8 +1888,8 @@ mod bigdecimal_serde {
     #[cfg(feature = "string-only")]
     impl<'de> de::Deserialize<'de> for BigDecimal {
         fn deserialize<D>(d: D) -> Result<Self, D::Error>
-            where
-                D: de::Deserializer<'de>,
+        where
+            D: de::Deserializer<'de>,
         {
             d.deserialize_str(BigDecimalVisitor)
         }
@@ -2598,6 +2594,7 @@ mod bigdecimal_tests {
             ("1.449999999", 1, "1.4"),
             ("-9999.444455556666", 10, "-9999.4444555567"),
             ("-12345678987654321.123456789", 8, "-12345678987654321.12345679"),
+            ("0.33333333333333333333333333333333333333333333333333333333333333333333333333333333333333", 0, "0"),
         ];
         for &(x, digits, y) in test_cases.iter() {
             let a = BigDecimal::from_str(x).unwrap();