Fix clippy errors after --all-features was enabled

morenol · morenol · commit 85d2ecd1c97c · 2020-11-10T21:24:04.000-04:00
diff --git a/src/linalg/nalgebra_bindings.rs b/src/linalg/nalgebra_bindings.rs
@@ -64,7 +64,7 @@ impl<T: RealNumber + 'static> BaseVector<T> for MatrixMN<T, U1, Dynamic> {
     }
 
     fn to_vec(&self) -> Vec<T> {
-        self.row(0).iter().map(|v| *v).collect()
+        self.row(0).iter().copied().collect()
     }
 
     fn zeros(len: usize) -> Self {
@@ -112,7 +112,7 @@ impl<T: RealNumber + 'static> BaseVector<T> for MatrixMN<T, U1, Dynamic> {
             let mut norm = T::zero();
 
             for xi in self.iter() {
-                norm = norm + xi.abs().powf(p);
+                norm += xi.abs().powf(p);
             }
 
             norm.powf(T::one() / p)
@@ -174,7 +174,7 @@ impl<T: RealNumber + 'static> BaseVector<T> for MatrixMN<T, U1, Dynamic> {
     }
 
     fn unique(&self) -> Vec<T> {
-        let mut result: Vec<T> = self.iter().map(|v| *v).collect();
+        let mut result: Vec<T> = self.iter().copied().collect();
         result.sort_by(|a, b| a.partial_cmp(b).unwrap());
         result.dedup();
         result
@@ -199,30 +199,26 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su
     }
 
     fn get_row_as_vec(&self, row: usize) -> Vec<T> {
-        self.row(row).iter().map(|v| *v).collect()
+        self.row(row).iter().copied().collect()
     }
 
     fn get_row(&self, row: usize) -> Self::RowVector {
         self.row(row).into_owned()
     }
 
     fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {
-        let mut r = 0;
-        for e in self.row(row).iter() {
+        for (r, e) in self.row(row).iter().enumerate() {
             result[r] = *e;
-            r += 1;
         }
     }
 
     fn get_col_as_vec(&self, col: usize) -> Vec<T> {
-        self.column(col).iter().map(|v| *v).collect()
+        self.column(col).iter().copied().collect()
     }
 
     fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {
-        let mut r = 0;
-        for e in self.column(col).iter() {
-            result[r] = *e;
-            r += 1;
+        for (c, e) in self.column(col).iter().enumerate() {
+            result[c] = *e;
         }
     }
 
@@ -368,7 +364,7 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su
             let mut norm = T::zero();
 
             for xi in self.iter() {
-                norm = norm + xi.abs().powf(p);
+                norm += xi.abs().powf(p);
             }
 
             norm.powf(T::one() / p)
@@ -477,7 +473,7 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su
             for c in 0..self.ncols() {
                 let p = (self[(r, c)] - max).exp();
                 self.set(r, c, p);
-                z = z + p;
+                z += p;
             }
         }
         for r in 0..self.nrows() {
@@ -514,7 +510,7 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su
     }
 
     fn unique(&self) -> Vec<T> {
-        let mut result: Vec<T> = self.iter().map(|v| *v).collect();
+        let mut result: Vec<T> = self.iter().copied().collect();
         result.sort_by(|a, b| a.partial_cmp(b).unwrap());
         result.dedup();
         result
diff --git a/src/linalg/ndarray_bindings.rs b/src/linalg/ndarray_bindings.rs
@@ -117,27 +117,27 @@ impl<T: RealNumber + ScalarOperand> BaseVector<T> for ArrayBase<OwnedRepr<T>, Ix
             let mut norm = T::zero();
 
             for xi in self.iter() {
-                norm = norm + xi.abs().powf(p);
+                norm += xi.abs().powf(p);
             }
 
             norm.powf(T::one() / p)
         }
     }
 
     fn div_element_mut(&mut self, pos: usize, x: T) {
-        self[pos] = self[pos] / x;
+        self[pos] /= x;
     }
 
     fn mul_element_mut(&mut self, pos: usize, x: T) {
-        self[pos] = self[pos] * x;
+        self[pos] *= x;
     }
 
     fn add_element_mut(&mut self, pos: usize, x: T) {
-        self[pos] = self[pos] + x;
+        self[pos] += x;
     }
 
     fn sub_element_mut(&mut self, pos: usize, x: T) {
-        self[pos] = self[pos] - x;
+        self[pos] -= x;
     }
 
     fn approximate_eq(&self, other: &Self, error: T) -> bool {
@@ -204,10 +204,8 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi
     }
 
     fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {
-        let mut r = 0;
-        for e in self.row(row).iter() {
+        for (r, e) in self.row(row).iter().enumerate() {
             result[r] = *e;
-            r += 1;
         }
     }
 
@@ -216,10 +214,8 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi
     }
 
     fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {
-        let mut r = 0;
-        for e in self.column(col).iter() {
-            result[r] = *e;
-            r += 1;
+        for (c, e) in self.column(col).iter().enumerate() {
+            result[c] = *e;
         }
     }
 
@@ -347,7 +343,7 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi
             let mut norm = T::zero();
 
             for xi in self.iter() {
-                norm = norm + xi.abs().powf(p);
+                norm += xi.abs().powf(p);
             }
 
             norm.powf(T::one() / p)
@@ -359,19 +355,19 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi
     }
 
     fn div_element_mut(&mut self, row: usize, col: usize, x: T) {
-        self[[row, col]] = self[[row, col]] / x;
+        self[[row, col]] /= x;
     }
 
     fn mul_element_mut(&mut self, row: usize, col: usize, x: T) {
-        self[[row, col]] = self[[row, col]] * x;
+        self[[row, col]] *= x;
     }
 
     fn add_element_mut(&mut self, row: usize, col: usize, x: T) {
-        self[[row, col]] = self[[row, col]] + x;
+        self[[row, col]] += x;
     }
 
     fn sub_element_mut(&mut self, row: usize, col: usize, x: T) {
-        self[[row, col]] = self[[row, col]] - x;
+        self[[row, col]] -= x;
     }
 
     fn negative_mut(&mut self) {
@@ -425,7 +421,7 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi
             for c in 0..self.ncols() {
                 let p = (self[(r, c)] - max).exp();
                 self.set(r, c, p);
-                z = z + p;
+                z += p;
             }
         }
         for r in 0..self.nrows() {
diff --git a/src/model_selection/mod.rs b/src/model_selection/mod.rs
@@ -292,10 +292,10 @@ mod tests {
         let x: DenseMatrix<f64> = DenseMatrix::rand(23, 100);
         let train_test_splits = k.split(&x);
 
-        assert_eq!(train_test_splits[0].1.len(), 12 as usize);
-        assert_eq!(train_test_splits[0].0.len(), 11 as usize);
-        assert_eq!(train_test_splits[1].0.len(), 12 as usize);
-        assert_eq!(train_test_splits[1].1.len(), 11 as usize);
+        assert_eq!(train_test_splits[0].1.len(), 12_usize);
+        assert_eq!(train_test_splits[0].0.len(), 11_usize);
+        assert_eq!(train_test_splits[1].0.len(), 12_usize);
+        assert_eq!(train_test_splits[1].1.len(), 11_usize);
     }
 
     #[test]

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ impl<T: RealNumber + 'static> BaseVector<T> for MatrixMN<T, U1, Dynamic> {`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`fn to_vec(&self) -> Vec<T> {`
`67`		`- self.row(0).iter().map(\|v\| *v).collect()`
	`67`	`+ self.row(0).iter().copied().collect()`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`fn zeros(len: usize) -> Self {`
`@@ -112,7 +112,7 @@ impl<T: RealNumber + 'static> BaseVector<T> for MatrixMN<T, U1, Dynamic> {`
`112`	`112`	`let mut norm = T::zero();`
`113`	`113`
`114`	`114`	`for xi in self.iter() {`
`115`		`- norm = norm + xi.abs().powf(p);`
	`115`	`+ norm += xi.abs().powf(p);`
`116`	`116`	`}`
`117`	`117`
`118`	`118`	`norm.powf(T::one() / p)`
`@@ -174,7 +174,7 @@ impl<T: RealNumber + 'static> BaseVector<T> for MatrixMN<T, U1, Dynamic> {`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	`fn unique(&self) -> Vec<T> {`
`177`		`- let mut result: Vec<T> = self.iter().map(\|v\| *v).collect();`
	`177`	`+ let mut result: Vec<T> = self.iter().copied().collect();`
`178`	`178`	`result.sort_by(\|a, b\| a.partial_cmp(b).unwrap());`
`179`	`179`	`result.dedup();`
`180`	`180`	`result`
`@@ -199,30 +199,26 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`fn get_row_as_vec(&self, row: usize) -> Vec<T> {`
`202`		`- self.row(row).iter().map(\|v\| *v).collect()`
	`202`	`+ self.row(row).iter().copied().collect()`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`fn get_row(&self, row: usize) -> Self::RowVector {`
`206`	`206`	`self.row(row).into_owned()`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {`
`210`		`- let mut r = 0;`
`211`		`- for e in self.row(row).iter() {`
	`210`	`+ for (r, e) in self.row(row).iter().enumerate() {`
`212`	`211`	`result[r] = *e;`
`213`		`- r += 1;`
`214`	`212`	`}`
`215`	`213`	`}`
`216`	`214`
`217`	`215`	`fn get_col_as_vec(&self, col: usize) -> Vec<T> {`
`218`		`- self.column(col).iter().map(\|v\| *v).collect()`
	`216`	`+ self.column(col).iter().copied().collect()`
`219`	`217`	`}`
`220`	`218`
`221`	`219`	`fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {`
`222`		`- let mut r = 0;`
`223`		`- for e in self.column(col).iter() {`
`224`		`- result[r] = *e;`
`225`		`- r += 1;`
	`220`	`+ for (c, e) in self.column(col).iter().enumerate() {`
	`221`	`+ result[c] = *e;`
`226`	`222`	`}`
`227`	`223`	`}`
`228`	`224`
`@@ -368,7 +364,7 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su`
`368`	`364`	`let mut norm = T::zero();`
`369`	`365`
`370`	`366`	`for xi in self.iter() {`
`371`		`- norm = norm + xi.abs().powf(p);`
	`367`	`+ norm += xi.abs().powf(p);`
`372`	`368`	`}`
`373`	`369`
`374`	`370`	`norm.powf(T::one() / p)`
`@@ -477,7 +473,7 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su`
`477`	`473`	`for c in 0..self.ncols() {`
`478`	`474`	`let p = (self[(r, c)] - max).exp();`
`479`	`475`	`self.set(r, c, p);`
`480`		`- z = z + p;`
	`476`	`+ z += p;`
`481`	`477`	`}`
`482`	`478`	`}`
`483`	`479`	`for r in 0..self.nrows() {`
`@@ -514,7 +510,7 @@ impl<T: RealNumber + Scalar + AddAssign + SubAssign + MulAssign + DivAssign + Su`
`514`	`510`	`}`
`515`	`511`
`516`	`512`	`fn unique(&self) -> Vec<T> {`
`517`		`- let mut result: Vec<T> = self.iter().map(\|v\| *v).collect();`
	`513`	`+ let mut result: Vec<T> = self.iter().copied().collect();`
`518`	`514`	`result.sort_by(\|a, b\| a.partial_cmp(b).unwrap());`
`519`	`515`	`result.dedup();`
`520`	`516`	`result`
Original file line number	Diff line number	Diff line change
`@@ -117,27 +117,27 @@ impl<T: RealNumber + ScalarOperand> BaseVector<T> for ArrayBase<OwnedRepr<T>, Ix`
`117`	`117`	`let mut norm = T::zero();`
`118`	`118`
`119`	`119`	`for xi in self.iter() {`
`120`		`- norm = norm + xi.abs().powf(p);`
	`120`	`+ norm += xi.abs().powf(p);`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`norm.powf(T::one() / p)`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`fn div_element_mut(&mut self, pos: usize, x: T) {`
`128`		`- self[pos] = self[pos] / x;`
	`128`	`+ self[pos] /= x;`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`fn mul_element_mut(&mut self, pos: usize, x: T) {`
`132`		`- self[pos] = self[pos] * x;`
	`132`	`+ self[pos] *= x;`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`fn add_element_mut(&mut self, pos: usize, x: T) {`
`136`		`- self[pos] = self[pos] + x;`
	`136`	`+ self[pos] += x;`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`fn sub_element_mut(&mut self, pos: usize, x: T) {`
`140`		`- self[pos] = self[pos] - x;`
	`140`	`+ self[pos] -= x;`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`fn approximate_eq(&self, other: &Self, error: T) -> bool {`
`@@ -204,10 +204,8 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi`
`204`	`204`	`}`
`205`	`205`
`206`	`206`	`fn copy_row_as_vec(&self, row: usize, result: &mut Vec<T>) {`
`207`		`- let mut r = 0;`
`208`		`- for e in self.row(row).iter() {`
	`207`	`+ for (r, e) in self.row(row).iter().enumerate() {`
`209`	`208`	`result[r] = *e;`
`210`		`- r += 1;`
`211`	`209`	`}`
`212`	`210`	`}`
`213`	`211`
`@@ -216,10 +214,8 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi`
`216`	`214`	`}`
`217`	`215`
`218`	`216`	`fn copy_col_as_vec(&self, col: usize, result: &mut Vec<T>) {`
`219`		`- let mut r = 0;`
`220`		`- for e in self.column(col).iter() {`
`221`		`- result[r] = *e;`
`222`		`- r += 1;`
	`217`	`+ for (c, e) in self.column(col).iter().enumerate() {`
	`218`	`+ result[c] = *e;`
`223`	`219`	`}`
`224`	`220`	`}`
`225`	`221`
`@@ -347,7 +343,7 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi`
`347`	`343`	`let mut norm = T::zero();`
`348`	`344`
`349`	`345`	`for xi in self.iter() {`
`350`		`- norm = norm + xi.abs().powf(p);`
	`346`	`+ norm += xi.abs().powf(p);`
`351`	`347`	`}`
`352`	`348`
`353`	`349`	`norm.powf(T::one() / p)`
`@@ -359,19 +355,19 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi`
`359`	`355`	`}`
`360`	`356`
`361`	`357`	`fn div_element_mut(&mut self, row: usize, col: usize, x: T) {`
`362`		`- self[[row, col]] = self[[row, col]] / x;`
	`358`	`+ self[[row, col]] /= x;`
`363`	`359`	`}`
`364`	`360`
`365`	`361`	`fn mul_element_mut(&mut self, row: usize, col: usize, x: T) {`
`366`		`- self[[row, col]] = self[[row, col]] * x;`
	`362`	`+ self[[row, col]] *= x;`
`367`	`363`	`}`
`368`	`364`
`369`	`365`	`fn add_element_mut(&mut self, row: usize, col: usize, x: T) {`
`370`		`- self[[row, col]] = self[[row, col]] + x;`
	`366`	`+ self[[row, col]] += x;`
`371`	`367`	`}`
`372`	`368`
`373`	`369`	`fn sub_element_mut(&mut self, row: usize, col: usize, x: T) {`
`374`		`- self[[row, col]] = self[[row, col]] - x;`
	`370`	`+ self[[row, col]] -= x;`
`375`	`371`	`}`
`376`	`372`
`377`	`373`	`fn negative_mut(&mut self) {`
`@@ -425,7 +421,7 @@ impl<T: RealNumber + ScalarOperand + AddAssign + SubAssign + MulAssign + DivAssi`
`425`	`421`	`for c in 0..self.ncols() {`
`426`	`422`	`let p = (self[(r, c)] - max).exp();`
`427`	`423`	`self.set(r, c, p);`
`428`		`- z = z + p;`
	`424`	`+ z += p;`
`429`	`425`	`}`
`430`	`426`	`}`
`431`	`427`	`for r in 0..self.nrows() {`