Fix clippy warnings

benches/seq_choose.rs

@@ -23,7 +23,7 @@ pub fn bench(c: &mut Criterion) {
 }
 
 fn bench_rng<Rng: RngCore + SeedableRng>(c: &mut Criterion, rng_name: &'static str) {
-    for length in [1, 2, 3, 10, 100, 1000].map(|x| black_box(x)) {
+    for length in [1, 2, 3, 10, 100, 1000].map(black_box) {
         c.bench_function(
             format!("choose_size-hinted_from_{length}_{rng_name}").as_str(),
             |b| {

benches/shuffle.rs

@@ -23,7 +23,7 @@ pub fn bench(c: &mut Criterion) {
 }
 
 fn bench_rng<Rng: RngCore + SeedableRng>(c: &mut Criterion, rng_name: &'static str) {
-    for length in [1, 2, 3, 10, 100, 1000, 10000].map(|x| black_box(x)) {
+    for length in [1, 2, 3, 10, 100, 1000, 10000].map(black_box) {
         c.bench_function(format!("shuffle_{length}_{rng_name}").as_str(), |b| {
             let mut rng = Rng::seed_from_u64(123);
             let mut vec: Vec<usize> = (0..length).collect();

rand_core/src/block.rs

@@ -470,20 +470,20 @@ mod test {
         let mut rng3 = rng1.clone();
 
         let mut a = [0; 16];
-        (&mut a[..4]).copy_from_slice(&rng1.next_u32().to_le_bytes());
-        (&mut a[4..12]).copy_from_slice(&rng1.next_u64().to_le_bytes());
-        (&mut a[12..]).copy_from_slice(&rng1.next_u32().to_le_bytes());
+        a[..4].copy_from_slice(&rng1.next_u32().to_le_bytes());
+        a[4..12].copy_from_slice(&rng1.next_u64().to_le_bytes());
+        a[12..].copy_from_slice(&rng1.next_u32().to_le_bytes());
 
         let mut b = [0; 16];
-        (&mut b[..4]).copy_from_slice(&rng2.next_u32().to_le_bytes());
-        (&mut b[4..8]).copy_from_slice(&rng2.next_u32().to_le_bytes());
-        (&mut b[8..]).copy_from_slice(&rng2.next_u64().to_le_bytes());
+        b[..4].copy_from_slice(&rng2.next_u32().to_le_bytes());
+        b[4..8].copy_from_slice(&rng2.next_u32().to_le_bytes());
+        b[8..].copy_from_slice(&rng2.next_u64().to_le_bytes());
         assert_eq!(a, b);
 
         let mut c = [0; 16];
-        (&mut c[..8]).copy_from_slice(&rng3.next_u64().to_le_bytes());
-        (&mut c[8..12]).copy_from_slice(&rng3.next_u32().to_le_bytes());
-        (&mut c[12..]).copy_from_slice(&rng3.next_u32().to_le_bytes());
+        c[..8].copy_from_slice(&rng3.next_u64().to_le_bytes());
+        c[8..12].copy_from_slice(&rng3.next_u32().to_le_bytes());
+        c[12..].copy_from_slice(&rng3.next_u32().to_le_bytes());
         assert_eq!(a, c);
     }
 
@@ -520,22 +520,22 @@ mod test {
         let mut rng3 = rng1.clone();
 
         let mut a = [0; 16];
-        (&mut a[..4]).copy_from_slice(&rng1.next_u32().to_le_bytes());
-        (&mut a[4..12]).copy_from_slice(&rng1.next_u64().to_le_bytes());
-        (&mut a[12..]).copy_from_slice(&rng1.next_u32().to_le_bytes());
+        a[..4].copy_from_slice(&rng1.next_u32().to_le_bytes());
+        a[4..12].copy_from_slice(&rng1.next_u64().to_le_bytes());
+        a[12..].copy_from_slice(&rng1.next_u32().to_le_bytes());
 
         let mut b = [0; 16];
-        (&mut b[..4]).copy_from_slice(&rng2.next_u32().to_le_bytes());
-        (&mut b[4..8]).copy_from_slice(&rng2.next_u32().to_le_bytes());
-        (&mut b[8..]).copy_from_slice(&rng2.next_u64().to_le_bytes());
+        b[..4].copy_from_slice(&rng2.next_u32().to_le_bytes());
+        b[4..8].copy_from_slice(&rng2.next_u32().to_le_bytes());
+        b[8..].copy_from_slice(&rng2.next_u64().to_le_bytes());
         assert_ne!(a, b);
         assert_eq!(&a[..4], &b[..4]);
         assert_eq!(&a[4..12], &b[8..]);
 
         let mut c = [0; 16];
-        (&mut c[..8]).copy_from_slice(&rng3.next_u64().to_le_bytes());
-        (&mut c[8..12]).copy_from_slice(&rng3.next_u32().to_le_bytes());
-        (&mut c[12..]).copy_from_slice(&rng3.next_u32().to_le_bytes());
+        c[..8].copy_from_slice(&rng3.next_u64().to_le_bytes());
+        c[8..12].copy_from_slice(&rng3.next_u32().to_le_bytes());
+        c[12..].copy_from_slice(&rng3.next_u32().to_le_bytes());
         assert_eq!(b, c);
     }
 }

rand_distr/src/binomial.rs

@@ -127,7 +127,7 @@ impl Distribution<u64> for Binomial {
                 let mut u: f64 = rng.gen();
                 let mut x = 0;
 
-                while u > r as f64 {
+                while u > r {
                     u -= r;
                     x += 1;
                     if x > BINV_MAX_X {
@@ -332,7 +332,7 @@ mod test {
         }
 
         let mean = results.iter().sum::<f64>() / results.len() as f64;
-        assert!((mean as f64 - expected_mean).abs() < expected_mean / 50.0);
+        assert!((mean - expected_mean).abs() < expected_mean / 50.0);
 
         let variance =
             results.iter().map(|x| (x - mean) * (x - mean)).sum::<f64>() / results.len() as f64;

rand_distr/src/cauchy.rs

@@ -142,7 +142,7 @@ mod test {
             let distr = Cauchy::new(m, s).unwrap();
             let mut rng = crate::test::rng(353);
             for x in buf {
-                *x = rng.sample(&distr);
+                *x = rng.sample(distr);
             }
         }
 

rand_distr/src/geometric.rs

@@ -59,7 +59,7 @@ impl Geometric {
     /// Construct a new `Geometric` with the given shape parameter `p`
     /// (probability of success on each trial).
     pub fn new(p: f64) -> Result<Self, Error> {
-        if !p.is_finite() || p < 0.0 || p > 1.0 {
+        if !p.is_finite() || !(0.0..=1.0).contains(&p) {
             Err(Error::InvalidProbability)
         } else if p == 0.0 || p >= 2.0 / 3.0 {
             Ok(Geometric { p, pi: p, k: 0 })
@@ -198,7 +198,7 @@ mod test {
         }
 
         let mean = results.iter().sum::<f64>() / results.len() as f64;
-        assert!((mean as f64 - expected_mean).abs() < expected_mean / 40.0);
+        assert!((mean - expected_mean).abs() < expected_mean / 40.0);
 
         let variance =
             results.iter().map(|x| (x - mean) * (x - mean)).sum::<f64>() / results.len() as f64;
@@ -230,7 +230,7 @@ mod test {
         }
 
         let mean = results.iter().sum::<f64>() / results.len() as f64;
-        assert!((mean as f64 - expected_mean).abs() < expected_mean / 50.0);
+        assert!((mean - expected_mean).abs() < expected_mean / 50.0);
 
         let variance =
             results.iter().map(|x| (x - mean) * (x - mean)).sum::<f64>() / results.len() as f64;

rand_distr/src/hypergeometric.rs

@@ -244,8 +244,8 @@ impl Distribution<u64> for Hypergeometric {
                 let mut u = rng.gen::<f64>();
                 while u > p && x < k as i64 { // the paper erroneously uses `until n < p`, which doesn't make any sense
                     u -= p;
-                    p *= ((n1 as i64 - x as i64) * (k as i64 - x as i64)) as f64;
-                    p /= ((x as i64 + 1) * (n2 as i64 - k as i64 + 1 + x as i64)) as f64;
+                    p *= ((n1 as i64 - x) * (k as i64 - x)) as f64;
+                    p /= ((x + 1) * (n2 as i64 - k as i64 + 1 + x)) as f64;
                     x += 1;
                 }
                 x
@@ -397,7 +397,7 @@ mod test {
         }
 
         let mean = results.iter().sum::<f64>() / results.len() as f64;
-        assert!((mean as f64 - expected_mean).abs() < expected_mean / 50.0);
+        assert!((mean - expected_mean).abs() < expected_mean / 50.0);
 
         let variance =
             results.iter().map(|x| (x - mean) * (x - mean)).sum::<f64>() / results.len() as f64;

rand_distr/src/normal_inverse_gaussian.rs

@@ -76,7 +76,7 @@ where
 {
     fn sample<R>(&self, rng: &mut R) -> F
     where R: Rng + ?Sized {
-        let inv_gauss = rng.sample(&self.inverse_gaussian);
+        let inv_gauss = rng.sample(self.inverse_gaussian);
 
         self.beta * inv_gauss + inv_gauss.sqrt() * rng.sample(StandardNormal)
     }

rand_distr/src/skew_normal.rs

@@ -247,7 +247,7 @@ mod tests {
         let mut rng = crate::test::rng(213);
         let mut buf = [0.0; 4];
         for x in &mut buf {
-            *x = rng.sample(&skew_normal);
+            *x = rng.sample(skew_normal);
         }
         for value in buf.iter() {
             assert!(value.is_nan());

src/distributions/bernoulli.rs

@@ -206,7 +206,7 @@ mod test {
         let distr = Bernoulli::new(0.4532).unwrap();
         let mut buf = [false; 10];
         for x in &mut buf {
-            *x = rng.sample(&distr);
+            *x = rng.sample(distr);
         }
         assert_eq!(buf, [
             true, false, false, true, false, false, true, true, true, true

src/distributions/float.rs

@@ -268,7 +268,7 @@ mod tests {
             let mut rng = crate::test::rng(0x6f44f5646c2a7334);
             let mut buf = [zero; 3];
             for x in &mut buf {
-                *x = rng.sample(&distr);
+                *x = rng.sample(distr);
             }
             assert_eq!(&buf, expected);
         }

src/distributions/other.rs

@@ -328,7 +328,7 @@ mod tests {
             let mut rng = crate::test::rng(807);
             let mut buf = [zero; 5];
             for x in &mut buf {
-                *x = rng.sample(&distr);
+                *x = rng.sample(distr);
             }
             assert_eq!(&buf, expected);
         }

src/distributions/uniform.rs

@@ -1676,6 +1676,7 @@ mod tests {
 
     #[test]
     fn test_uniform_from_std_range_bad_limits() {
+        #![allow(clippy::reversed_empty_ranges)]
         assert!(Uniform::try_from(100..10).is_err());
         assert!(Uniform::try_from(100..100).is_err());
         assert!(Uniform::try_from(100.0..10.0).is_err());
@@ -1695,6 +1696,7 @@ mod tests {
 
     #[test]
     fn test_uniform_from_std_range_inclusive_bad_limits() {
+        #![allow(clippy::reversed_empty_ranges)]
         assert!(Uniform::try_from(100..=10).is_err());
         assert!(Uniform::try_from(100..=99).is_err());
         assert!(Uniform::try_from(100.0..=10.0).is_err());
@@ -1760,6 +1762,6 @@ mod tests {
         assert_eq!(Uniform::new(1.0, 2.0).unwrap(), Uniform::new(1.0, 2.0).unwrap());
 
         // To cover UniformInt
-        assert_eq!(Uniform::new(1 as u32, 2 as u32).unwrap(), Uniform::new(1 as u32, 2 as u32).unwrap());
+        assert_eq!(Uniform::new(1_u32, 2_u32).unwrap(), Uniform::new(1_u32, 2_u32).unwrap());
     }
 }

src/lib.rs

@@ -54,6 +54,7 @@
 #![allow(
     clippy::float_cmp,
     clippy::neg_cmp_op_on_partial_ord,
+    clippy::nonminimal_bool
 )]
 
 #[cfg(feature = "std")] extern crate std;

src/seq/coin_flipper.rs

@@ -37,9 +37,9 @@ impl<R: RngCore> CoinFlipper<R> {
 
         if self.flip_c_heads(c) {
             let numerator = 1 << c;
-            return self.gen_ratio(numerator, d);
+            self.gen_ratio(numerator, d)
         } else {
-            return false;
+            false
         }
     }
 

src/seq/index.rs

@@ -105,12 +105,12 @@ impl PartialEq for IndexVec {
     fn eq(&self, other: &IndexVec) -> bool {
         use self::IndexVec::*;
         match (self, other) {
-            (&U32(ref v1), &U32(ref v2)) => v1 == v2,
-            (&USize(ref v1), &USize(ref v2)) => v1 == v2,
-            (&U32(ref v1), &USize(ref v2)) => {
+            (U32(v1), U32(v2)) => v1 == v2,
+            (USize(v1), USize(v2)) => v1 == v2,
+            (U32(v1), USize(v2)) => {
                 (v1.len() == v2.len()) && (v1.iter().zip(v2.iter()).all(|(x, y)| *x as usize == *y))
             }
-            (&USize(ref v1), &U32(ref v2)) => {
+            (USize(v1), U32(v2)) => {
                 (v1.len() == v2.len()) && (v1.iter().zip(v2.iter()).all(|(x, y)| *x == *y as usize))
             }
         }