Update formatting

Author: dhardy

examples/monty-hall.rs

@@ -26,8 +26,8 @@
 //!
 //! [Monty Hall Problem]: https://en.wikipedia.org/wiki/Monty_Hall_problem
 
-use rand::distr::{Distribution, Uniform};
 use rand::Rng;
+use rand::distr::{Distribution, Uniform};
 
 struct SimulationResult {
     win: bool,

examples/rayon-monte-carlo.rs

@@ -1,80 +1,80 @@
-// Copyright 2018 Developers of the Rand project.
-// Copyright 2013-2018 The Rust Project Developers.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! # Monte Carlo estimation of π with a chosen seed and rayon for parallelism
-//!
-//! Imagine that we have a square with sides of length 2 and a unit circle
-//! (radius = 1), both centered at the origin. The areas are:
-//!
-//! ```text
-//!     area of circle  = πr² = π * r * r = π
-//!     area of square  = 2² = 4
-//! ```
-//!
-//! The circle is entirely within the square, so if we sample many points
-//! randomly from the square, roughly π / 4 of them should be inside the circle.
-//!
-//! We can use the above fact to estimate the value of π: pick many points in
-//! the square at random, calculate the fraction that fall within the circle,
-//! and multiply this fraction by 4.
-//!
-//! Note on determinism:
-//! It's slightly tricky to build a parallel simulation using Rayon
-//! which is both efficient *and* reproducible.
-//!
-//! Rayon's ParallelIterator api does not guarantee that the work will be
-//! batched into identical batches on every run, so we can't simply use
-//! map_init to construct one RNG per Rayon batch.
-//!
-//! Instead, we do our own batching, so that a Rayon work item becomes a
-//! batch. Then we can fix our rng stream to the batched work item.
-//! Batching amortizes the cost of constructing the Rng from a fixed seed
-//! over BATCH_SIZE trials. Manually batching also turns out to be faster
-//! for the nondeterministic version of this program as well.
-
-use rand::distr::{Distribution, Uniform};
-use rand_chacha::{rand_core::SeedableRng, ChaCha8Rng};
-use rayon::prelude::*;
-
-static SEED: u64 = 0;
-static BATCH_SIZE: u64 = 10_000;
-static BATCHES: u64 = 1000;
-
-fn main() {
-    let range = Uniform::new(-1.0f64, 1.0).unwrap();
-
-    let in_circle = (0..BATCHES)
-        .into_par_iter()
-        .map(|i| {
-            let mut rng = ChaCha8Rng::seed_from_u64(SEED);
-            // We chose ChaCha because it's fast, has suitable statistical properties for simulation,
-            // and because it supports this set_stream() api, which lets us choose a different stream
-            // per work item. ChaCha supports 2^64 independent streams.
-            rng.set_stream(i);
-            let mut count = 0;
-            for _ in 0..BATCH_SIZE {
-                let a = range.sample(&mut rng);
-                let b = range.sample(&mut rng);
-                if a * a + b * b <= 1.0 {
-                    count += 1;
-                }
-            }
-            count
-        })
-        .sum::<usize>();
-
-    // assert this is deterministic
-    assert_eq!(in_circle, 7852263);
-
-    // prints something close to 3.14159...
-    println!(
-        "π is approximately {}",
-        4. * (in_circle as f64) / ((BATCH_SIZE * BATCHES) as f64)
-    );
-}
+// Copyright 2018 Developers of the Rand project.
+// Copyright 2013-2018 The Rust Project Developers.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! # Monte Carlo estimation of π with a chosen seed and rayon for parallelism
+//!
+//! Imagine that we have a square with sides of length 2 and a unit circle
+//! (radius = 1), both centered at the origin. The areas are:
+//!
+//! ```text
+//!     area of circle  = πr² = π * r * r = π
+//!     area of square  = 2² = 4
+//! ```
+//!
+//! The circle is entirely within the square, so if we sample many points
+//! randomly from the square, roughly π / 4 of them should be inside the circle.
+//!
+//! We can use the above fact to estimate the value of π: pick many points in
+//! the square at random, calculate the fraction that fall within the circle,
+//! and multiply this fraction by 4.
+//!
+//! Note on determinism:
+//! It's slightly tricky to build a parallel simulation using Rayon
+//! which is both efficient *and* reproducible.
+//!
+//! Rayon's ParallelIterator api does not guarantee that the work will be
+//! batched into identical batches on every run, so we can't simply use
+//! map_init to construct one RNG per Rayon batch.
+//!
+//! Instead, we do our own batching, so that a Rayon work item becomes a
+//! batch. Then we can fix our rng stream to the batched work item.
+//! Batching amortizes the cost of constructing the Rng from a fixed seed
+//! over BATCH_SIZE trials. Manually batching also turns out to be faster
+//! for the nondeterministic version of this program as well.
+
+use rand::distr::{Distribution, Uniform};
+use rand_chacha::{ChaCha8Rng, rand_core::SeedableRng};
+use rayon::prelude::*;
+
+static SEED: u64 = 0;
+static BATCH_SIZE: u64 = 10_000;
+static BATCHES: u64 = 1000;
+
+fn main() {
+    let range = Uniform::new(-1.0f64, 1.0).unwrap();
+
+    let in_circle = (0..BATCHES)
+        .into_par_iter()
+        .map(|i| {
+            let mut rng = ChaCha8Rng::seed_from_u64(SEED);
+            // We chose ChaCha because it's fast, has suitable statistical properties for simulation,
+            // and because it supports this set_stream() api, which lets us choose a different stream
+            // per work item. ChaCha supports 2^64 independent streams.
+            rng.set_stream(i);
+            let mut count = 0;
+            for _ in 0..BATCH_SIZE {
+                let a = range.sample(&mut rng);
+                let b = range.sample(&mut rng);
+                if a * a + b * b <= 1.0 {
+                    count += 1;
+                }
+            }
+            count
+        })
+        .sum::<usize>();
+
+    // assert this is deterministic
+    assert_eq!(in_circle, 7852263);
+
+    // prints something close to 3.14159...
+    println!(
+        "π is approximately {}",
+        4. * (in_circle as f64) / ((BATCH_SIZE * BATCHES) as f64)
+    );
+}

rand_core/src/lib.rs

@@ -597,9 +597,9 @@ pub struct RngReadAdapter<'a, R: TryRngCore + ?Sized> {
 impl<R: TryRngCore + ?Sized> std::io::Read for RngReadAdapter<'_, R> {
     #[inline]
     fn read(&mut self, buf: &mut [u8]) -> Result<usize, std::io::Error> {
-        self.inner.try_fill_bytes(buf).map_err(|err| {
-            std::io::Error::other(std::format!("RNG error: {err}"))
-        })?;
+        self.inner
+            .try_fill_bytes(buf)
+            .map_err(|err| std::io::Error::other(std::format!("RNG error: {err}")))?;
         Ok(buf.len())
     }
 }

rand_pcg/src/lib.rs

@@ -95,6 +95,6 @@ mod pcg64;
 
 pub use rand_core;
 
+pub use self::pcg64::{Lcg64Xsh32, Pcg32};
 pub use self::pcg128::{Lcg128Xsl64, Mcg128Xsl64, Pcg64, Pcg64Mcg};
 pub use self::pcg128cm::{Lcg128CmDxsm64, Pcg64Dxsm};
-pub use self::pcg64::{Lcg64Xsh32, Pcg32};

rand_pcg/src/pcg128.rs

@@ -14,7 +14,7 @@
 const MULTIPLIER: u128 = 0x2360_ED05_1FC6_5DA4_4385_DF64_9FCC_F645;
 
 use core::fmt;
-use rand_core::{impls, le, RngCore, SeedableRng};
+use rand_core::{RngCore, SeedableRng, impls, le};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 

rand_pcg/src/pcg128cm.rs

@@ -14,7 +14,7 @@
 const MULTIPLIER: u64 = 15750249268501108917;
 
 use core::fmt;
-use rand_core::{impls, le, RngCore, SeedableRng};
+use rand_core::{RngCore, SeedableRng, impls, le};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 

rand_pcg/src/pcg64.rs

@@ -11,7 +11,7 @@
 //! PCG random number generators
 
 use core::fmt;
-use rand_core::{impls, le, RngCore, SeedableRng};
+use rand_core::{RngCore, SeedableRng, impls, le};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 

src/distr/bernoulli.rs

@@ -8,8 +8,8 @@
 
 //! The Bernoulli distribution `Bernoulli(p)`.
 
-use crate::distr::Distribution;
 use crate::Rng;
+use crate::distr::Distribution;
 use core::fmt;
 
 #[cfg(feature = "serde")]
@@ -165,8 +165,8 @@ impl Distribution<bool> for Bernoulli {
 #[cfg(test)]
 mod test {
     use super::Bernoulli;
-    use crate::distr::Distribution;
     use crate::Rng;
+    use crate::distr::Distribution;
 
     #[test]
     #[cfg(feature = "serde")]
@@ -232,7 +232,9 @@ mod test {
         }
         assert_eq!(
             buf,
-            [true, false, false, true, false, false, true, true, true, true]
+            [
+                true, false, false, true, false, false, true, true, true, true
+            ]
         );
     }
 

src/distr/distribution.rs

@@ -203,8 +203,8 @@ pub trait SampleString {
 
 #[cfg(test)]
 mod tests {
-    use crate::distr::{Distribution, Uniform};
     use crate::Rng;
+    use crate::distr::{Distribution, Uniform};
 
     #[test]
     fn test_distributions_iter() {

src/distr/float.rs

@@ -8,9 +8,9 @@
 
 //! Basic floating-point number distributions
 
+use crate::Rng;
 use crate::distr::utils::{FloatAsSIMD, FloatSIMDUtils, IntAsSIMD};
 use crate::distr::{Distribution, StandardUniform};
-use crate::Rng;
 use core::mem;
 #[cfg(feature = "simd_support")]
 use core::simd::prelude::*;