Fix or allow clippy warnings

Author: akubera

src/lib.rs

@@ -39,6 +39,11 @@
 //!
 //! println!("Input ({}) with 10 decimals: {} vs {})", input, dec, float);
 //! ```
+#![allow(clippy::unreadable_literal)]
+#![allow(clippy::needless_return)]
+#![allow(clippy::suspicious_arithmetic_impl)]
+#![allow(clippy::suspicious_op_assign_impl)]
+#![allow(clippy::redundant_field_names)]
 
 extern crate num_bigint;
 extern crate num_integer;
@@ -61,6 +66,8 @@ use num_bigint::{BigInt, ParseBigIntError, Sign, ToBigInt};
 use num_integer::Integer;
 pub use traits::{FromPrimitive, Num, One, Signed, ToPrimitive, Zero};
 
+const LOG2_10: f64 = 3.321928094887362_f64;
+
 #[macro_use]
 mod macros;
 
@@ -93,7 +100,7 @@ fn count_decimal_digits(int: &BigInt) -> u64 {
     // guess number of digits based on number of bits in UInt
     let mut digits = (int.bits() as f64 / 3.3219280949) as u64;
     let mut num = ten_to_the(digits);
-    while int >= &num {
+    while *int >= num {
         num *= 10u8;
         digits += 1;
     }
@@ -118,11 +125,11 @@ fn get_rounding_term(num: &BigInt) -> u8 {
 
     // loop-method
     loop {
-        if num < &n {
+        if *num < n {
             return 1;
         }
         n *= 5;
-        if num < &n {
+        if *num < n {
             return 0;
         }
         n *= 2;
@@ -389,15 +396,14 @@ impl BigDecimal {
 
         // make guess
         let guess = {
-            let log2_10 = 3.32192809488736234787031942948939018_f64;
             let magic_guess_scale = 1.1951678538495576_f64;
-            let initial_guess = (self.int_val.bits() as f64 - self.scale as f64 * log2_10) / 2.0;
+            let initial_guess = (self.int_val.bits() as f64 - self.scale as f64 * LOG2_10) / 2.0;
             let res = magic_guess_scale * initial_guess.exp2();
             if res.is_normal() {
                 BigDecimal::try_from(res).unwrap()
             } else {
                 // can't guess with float - just guess magnitude
-                let scale = (self.int_val.bits() as f64 / -log2_10 + self.scale as f64).round() as i64;
+                let scale = (self.int_val.bits() as f64 / -LOG2_10 + self.scale as f64).round() as i64;
                 BigDecimal::new(BigInt::from(1), scale / 2)
             }
         };
@@ -462,15 +468,14 @@ impl BigDecimal {
 
         // make guess
         let guess = {
-            let log2_10 = 3.32192809488736234787031942948939018_f64;
             let magic_guess_scale = 1.124960491619939_f64;
-            let initial_guess = (self.int_val.bits() as f64 - self.scale as f64 * log2_10) / 3.0;
+            let initial_guess = (self.int_val.bits() as f64 - self.scale as f64 * LOG2_10) / 3.0;
             let res = magic_guess_scale * initial_guess.exp2();
             if res.is_normal() {
                 BigDecimal::try_from(res).unwrap()
             } else {
                 // can't guess with float - just guess magnitude
-                let scale = (self.int_val.bits() as f64 / log2_10 - self.scale as f64).round() as i64;
+                let scale = (self.int_val.bits() as f64 / LOG2_10 - self.scale as f64).round() as i64;
                 BigDecimal::new(BigInt::from(1), -scale / 3)
             }
         };
@@ -530,16 +535,15 @@ impl BigDecimal {
             let bits = self.int_val.bits() as f64;
             let scale = self.scale as f64;
 
-            let log2_10 = 3.32192809488736234787031942948939018_f64;
             let magic_factor = 0.721507597259061_f64;
-            let initial_guess = scale * log2_10 - bits;
+            let initial_guess = scale * LOG2_10 - bits;
             let res = magic_factor * initial_guess.exp2();
 
             if res.is_normal() {
                 BigDecimal::try_from(res).unwrap()
             } else {
                 // can't guess with float - just guess magnitude
-                let scale = (bits / log2_10 + scale).round() as i64;
+                let scale = (bits / LOG2_10 + scale).round() as i64;
                 BigDecimal::new(BigInt::from(1), -scale)
             }
         };
@@ -1271,7 +1275,7 @@ fn impl_division(mut num: BigInt, den: &BigInt, mut scale: i64, max_precision: u
     }
 
     // shift digits until numerator is larger than denominator (set scale appropriately)
-    while &num < den {
+    while num < *den {
         scale += 1;
         num *= 10;
     }
@@ -1325,7 +1329,7 @@ impl Div<BigDecimal> for BigDecimal {
 
         let scale = self.scale - other.scale;
 
-        if &self.int_val == &other.int_val {
+        if self.int_val == other.int_val {
             return BigDecimal {
                 int_val: 1.into(),
                 scale: scale,
@@ -1351,7 +1355,7 @@ impl<'a> Div<&'a BigDecimal> for BigDecimal {
 
         let scale = self.scale - other.scale;
 
-        if &self.int_val == &other.int_val {
+        if self.int_val == other.int_val {
             return BigDecimal {
                 int_val: 1.into(),
                 scale: scale,
@@ -1739,6 +1743,7 @@ macro_rules! impl_from_type {
     ($FromType:ty, $AsType:ty) => {
         impl From<$FromType> for BigDecimal {
             #[inline]
+            #[allow(clippy::cast_lossless)]
             fn from(n: $FromType) -> Self {
                 BigDecimal::from(n as $AsType)
             }
@@ -1972,7 +1977,7 @@ mod bigdecimal_serde {
     }
 }
 
-#[cfg_attr(rustfmt, rustfmt_skip)]
+#[rustfmt::skip]
 #[cfg(test)]
 mod bigdecimal_tests {
     use BigDecimal;

src/macros.rs

@@ -179,6 +179,7 @@ macro_rules! impl_div_for_float_primitive {
             type Output = BigDecimal;
 
             #[inline]
+            #[allow(clippy::float_cmp)]
             fn div(self, den: $res) -> Self::Output {
                 if den.is_nan() {
                     BigDecimal::zero()