fix errors clippy

Author: triuyen

src/financial/black_scholes.rs

@@ -52,44 +52,41 @@ pub fn black_scholes(
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    #[test]
-    fn my_test() {
-        macro_rules! test_black_scholes {
-            ($($name:ident: $inputs:expr,)*) => {
-                $(
-                    fn $name() {
-                        let (spot_price, strike_price, time_to_maturity, risk_free_rate, volatility) = $inputs;
-                        let expected = black_scholes(spot_price, strike_price, time_to_maturity, risk_free_rate, volatility).unwrap();
-                        assert!(expected >= 0.0);
-                    }
-                )*
-            }
+    macro_rules! test_black_scholes {
+        ($($name:ident: $inputs:expr,)*) => {
+            $(
+                #[test]
+                fn $name() {
+                    let (spot_price, strike_price, time_to_maturity, risk_free_rate, volatility) = $inputs;
+                    let expected = black_scholes(spot_price, strike_price, time_to_maturity, risk_free_rate, volatility).unwrap();
+                    assert!(expected >= 0.0);
+                }
+            )*
         }
+    }
 
-        macro_rules! test_black_scholes_Err {
-            ($($name:ident: $inputs:expr,)*) => {
-                $(
-                    #[test]
-                    fn $name() {
-                        let (spot_price, strike_price, time_to_maturity, risk_free_rate, volatility) = $inputs;
-                        assert_eq!(black_scholes(spot_price, strike_price, time_to_maturity, risk_free_rate, volatility).unwrap_err(), BlackScholesError::InvalidParameters);
-                    }
-                )*
-            }
+    macro_rules! test_black_scholes_Err {
+        ($($name:ident: $inputs:expr,)*) => {
+            $(
+                #[test]
+                fn $name() {
+                    let (spot_price, strike_price, time_to_maturity, risk_free_rate, volatility) = $inputs;
+                    assert_eq!(black_scholes(spot_price, strike_price, time_to_maturity, risk_free_rate, volatility).unwrap_err(), BlackScholesError::InvalidParameters);
+                }
+            )*
         }
+    }
 
-        test_black_scholes! {
-            valid_parameters: (100.0, 100.0, 1.0, 0.05, 0.2),
-            another_valid_case: (150.0, 100.0, 2.0, 0.03, 0.25),
-        }
+    test_black_scholes! {
+        valid_parameters: (100.0, 100.0, 1.0, 0.05, 0.2),
+        another_valid_case: (150.0, 100.0, 2.0, 0.03, 0.25),
+    }
 
-        test_black_scholes_Err! {
-            negative_spot_price: (-100.0, 100.0, 1.0, 0.05, 0.2),
-            zero_strike_price: (100.0, 0.0, 1.0, 0.05, 0.2),
-            negative_time_to_maturity: (100.0, 100.0, -1.0, 0.05, 0.2),
-            negative_risk_free_rate: (100.0, 100.0, 1.0, -0.05, 0.2),
-            negative_volatility: (100.0, 100.0, 1.0, 0.05, -0.2),
-        }
+    test_black_scholes_Err! {
+        negative_spot_price: (-100.0, 100.0, 1.0, 0.05, 0.2),
+        zero_strike_price: (100.0, 0.0, 1.0, 0.05, 0.2),
+        negative_time_to_maturity: (100.0, 100.0, -1.0, 0.05, 0.2),
+        negative_risk_free_rate: (100.0, 100.0, 1.0, -0.05, 0.2),
+        negative_volatility: (100.0, 100.0, 1.0, 0.05, -0.2),
     }
 }

src/general/huffman_encoding.rs

@@ -174,7 +174,9 @@ mod tests {
     use super::*;
     fn get_frequency(bytes: &[u8]) -> Vec<(u8, u64)> {
         let mut cnts: Vec<u64> = vec![0; 256];
-        bytes.iter().for_each(|&b| cnts[b as usize] += 1);
+        for &b in bytes.iter() {
+            cnts[b as usize] += 1;
+        }
         let mut result = vec![];
         cnts.iter()
             .enumerate()

src/geometry/ramer_douglas_peucker.rs

@@ -104,7 +104,7 @@ mod tests {
 
         assert_eq!(ramer_douglas_peucker(&[], epsilon), vec![]);
         assert_eq!(
-            ramer_douglas_peucker(&[a.clone()], epsilon),
+            ramer_douglas_peucker(std::slice::from_ref(&a), epsilon),
             vec![a.clone()]
         );
         assert_eq!(

src/graph/graph_enumeration.rs

@@ -41,7 +41,9 @@ mod tests {
         let mut result = enumerate_graph(&graph);
         let expected = vec![vec![], vec![2, 3], vec![1, 3, 4], vec![1, 2], vec![2]];
 
-        result.iter_mut().for_each(|v| v.sort_unstable());
+        for v in result.iter_mut() {
+            v.sort_unstable();
+        }
         assert_eq!(result, expected);
     }
 
@@ -55,7 +57,9 @@ mod tests {
         let mut result = enumerate_graph(&graph);
         let expected = vec![vec![], vec![2, 3], vec![1, 3, 4], vec![1, 2], vec![2]];
 
-        result.iter_mut().for_each(|v| v.sort_unstable());
+        for v in result.iter_mut() {
+            v.sort_unstable();
+        }
         assert_eq!(result, expected);
     }
 }

src/math/fast_fourier_transform.rs

@@ -192,7 +192,9 @@ mod tests {
         polynomial.append(&mut vec![0.0; 4]);
         let permutation = fast_fourier_transform_input_permutation(polynomial.len());
         let mut fft = fast_fourier_transform(&polynomial, &permutation);
-        fft.iter_mut().for_each(|num| *num *= *num);
+        for num in fft.iter_mut() {
+            *num *= *num;
+        }
         let ifft = inverse_fast_fourier_transform(&fft, &permutation);
         let expected = [1.0, 2.0, 1.0, 4.0, 4.0, 0.0, 4.0, 0.0, 0.0];
         for (x, y) in ifft.iter().zip(expected.iter()) {
@@ -210,7 +212,9 @@ mod tests {
         polynomial.append(&mut vec![0.0f64; n]);
         let permutation = fast_fourier_transform_input_permutation(polynomial.len());
         let mut fft = fast_fourier_transform(&polynomial, &permutation);
-        fft.iter_mut().for_each(|num| *num *= *num);
+        for num in fft.iter_mut() {
+            *num *= *num;
+        }
         let ifft = inverse_fast_fourier_transform(&fft, &permutation);
         let expected = (0..((n << 1) - 1)).map(|i| std::cmp::min(i + 1, (n << 1) - 1 - i) as f64);
         for (&x, y) in ifft.iter().zip(expected) {

src/math/pollard_rho.rs

@@ -201,7 +201,7 @@ mod test {
     use super::*;
 
     fn check_is_proper_factor(number: u64, factor: u64) -> bool {
-        factor > 1 && factor < number && ((number % factor) == 0)
+        factor > 1 && factor < number && number.is_multiple_of(factor)
     }
 
     fn check_factorization(number: u64, factors: &[u64]) -> bool {