fix clippy

Author: Mec-iS

src/algorithm/sort/quick_sort.rs

@@ -1,6 +1,7 @@
 use num_traits::Num;
 
 pub trait QuickArgSort {
+    #[allow(dead_code)]
     fn quick_argsort_mut(&mut self) -> Vec<usize>;
 
     #[allow(dead_code)]

src/optimization/line_search.rs

@@ -6,8 +6,8 @@ pub trait LineSearchMethod<T: Float> {
     /// Find alpha that satisfies strong Wolfe conditions.
     fn search(
         &self,
-        f: &(dyn Fn(T) -> T),
-        df: &(dyn Fn(T) -> T),
+        f: &dyn Fn(T) -> T,
+        df: &dyn Fn(T) -> T,
         alpha: T,
         f0: T,
         df0: T,
@@ -55,8 +55,8 @@ impl<T: Float> Default for Backtracking<T> {
 impl<T: Float> LineSearchMethod<T> for Backtracking<T> {
     fn search(
         &self,
-        f: &(dyn Fn(T) -> T),
-        _: &(dyn Fn(T) -> T),
+        f: &dyn Fn(T) -> T,
+        _: &dyn Fn(T) -> T,
         alpha: T,
         f0: T,
         df0: T,

src/tree/decision_tree_classifier.rs

@@ -674,19 +674,25 @@ impl<TX: Number + PartialOrd, TY: Number + Ord, X: Array2<TX>, Y: Array1<TY>>
     ) -> bool {
         let (n_rows, n_attr) = visitor.x.shape();
 
-        let mut label = Option::None;
+        let mut label = None;
         let mut is_pure = true;
         for i in 0..n_rows {
             if visitor.samples[i] > 0 {
-                if label.is_none() {
-                    label = Option::Some(visitor.y[i]);
-                } else if visitor.y[i] != label.unwrap() {
-                    is_pure = false;
-                    break;
+                match label {
+                    None => {
+                        label = Some(visitor.y[i]);
+                    }
+                    Some(current_label) => {
+                        if visitor.y[i] != current_label {
+                            is_pure = false;
+                            break;
+                        }
+                    }
                 }
             }
         }
 
+
         let n = visitor.samples.iter().sum();
         let mut count = vec![0; self.num_classes];
         let mut false_count = vec![0; self.num_classes];

src/xgboost/xgb_regressor.rs

@@ -96,7 +96,7 @@ impl Objective {
     pub fn gradient<TY: Number, Y: Array1<TY>>(&self, y_true: &Y, y_pred: &Vec<f64>) -> Vec<f64> {
         match self {
             Objective::MeanSquaredError => zip(y_true.iterator(0), y_pred)
-                .map(|(true_val, pred_val)| (*pred_val - true_val.to_f64().unwrap()))
+                .map(|(true_val, pred_val)| *pred_val - true_val.to_f64().unwrap())
                 .collect(),
         }
     }