Merge pull request #1138 from striezel-stash/fix-typos

fix some typos

Author: vks

CHANGELOG.md

@@ -678,4 +678,4 @@ when updating from `rand 0.7.0` without also updating `rand_core`.
 
 ## [0.10-pre] - 2014-03-02
 ### Added
-- Seperate `rand` out of the standard library
+- Separate `rand` out of the standard library

README.md

@@ -143,7 +143,7 @@ unavailable.
 
 The WASM target `wasm32-unknown-unknown` is not *automatically* supported by
 `rand` or `getrandom`. To solve this, either use a different target such as
-`wasm32-wasi` or add a direct dependancy on `getrandom` with the `js` feature
+`wasm32-wasi` or add a direct dependency on `getrandom` with the `js` feature
 (if the target supports JavaScript). See
 [getrandom#WebAssembly support](https://docs.rs/getrandom/latest/getrandom/#webassembly-support).
 

SECURITY.md

@@ -8,7 +8,7 @@ No binding guarantees can be provided.
 ## Security premises
 
 Rand provides the trait `rand_core::CryptoRng` aka `rand::CryptoRng` as a marker
-trait. Generators implementating `RngCore` *and* `CryptoRng`, and given the
+trait. Generators implementing `RngCore` *and* `CryptoRng`, and given the
 additional constraints that:
 
 -   Instances of seedable RNGs (those implementing `SeedableRng`) are

rand_core/src/block.rs

@@ -95,7 +95,7 @@ pub trait BlockRngCore {
 /// [`fill_bytes`] / [`try_fill_bytes`] is called on a large array. These methods
 /// also handle the bookkeeping of when to generate a new batch of values.
 ///
-/// No whole generated `u32` values are thown away and all values are consumed
+/// No whole generated `u32` values are thrown away and all values are consumed
 /// in-order. [`next_u32`] simply takes the next available `u32` value.
 /// [`next_u64`] is implemented by combining two `u32` values, least
 /// significant first. [`fill_bytes`] and [`try_fill_bytes`] consume a whole

rand_distr/README.md

@@ -28,7 +28,7 @@ for some distributions (in particular, `Dirichlet` and `WeightedAliasIndex`).
 
 The floating point functions from `num_traits` and `libm` are used to support
 `no_std` environments and ensure reproducibility. If the floating point
-functions from `std` are prefered, which may provide better accuracy and
+functions from `std` are preferred, which may provide better accuracy and
 performance but may produce different random values, the `std_math` feature
 can be enabled.
 

rand_distr/src/binomial.rs

@@ -105,7 +105,7 @@ impl Distribution<u64> for Binomial {
         // random variate generation. Commun. ACM 31, 2 (February 1988),
         // 216-222. http://dx.doi.org/10.1145/42372.42381
 
-        // Threshold for prefering the BINV algorithm. The paper suggests 10,
+        // Threshold for preferring the BINV algorithm. The paper suggests 10,
         // Ranlib uses 30, and GSL uses 14.
         const BINV_THRESHOLD: f64 = 10.;
 
@@ -242,7 +242,7 @@ impl Distribution<u64> for Binomial {
                     }
                 }
 
-                // Step 5.2: Squeezing. Check the value of ln(v) againts upper and
+                // Step 5.2: Squeezing. Check the value of ln(v) against upper and
                 // lower bound of ln(f(y)).
                 let k = k as f64;
                 let rho = (k / npq) * ((k * (k / 3. + 0.625) + 1. / 6.) / npq + 0.5);

rand_distr/src/hypergeometric.rs

@@ -29,7 +29,7 @@ enum SamplingMethod {
 /// `f(k) = binomial(K, k) * binomial(N-K, n-k) / binomial(N, n)`,
 /// where `binomial(a, b) = a! / (b! * (a - b)!)`.
 /// 
-/// The [binomial distribution](crate::Binomial) is the analagous distribution
+/// The [binomial distribution](crate::Binomial) is the analogous distribution
 /// for sampling with replacement. It is a good approximation when the population
 /// size is much larger than the sample size.
 /// 

rand_distr/src/poisson.rs

@@ -109,7 +109,7 @@ where F: Float + FloatConst, Standard: Distribution<F>
                 loop {
                     // draw from the Cauchy distribution
                     comp_dev = rng.sample(cauchy);
-                    // shift the peak of the comparison ditribution
+                    // shift the peak of the comparison distribution
                     result = self.sqrt_2lambda * comp_dev + self.lambda;
                     // repeat the drawing until we are in the range of possible values
                     if result >= F::zero() {

rand_distr/src/utils.rs

@@ -91,14 +91,14 @@ where
         let i = bits as usize & 0xff;
 
         let u = if symmetric {
-            // Convert to a value in the range [2,4) and substract to get [-1,1)
+            // Convert to a value in the range [2,4) and subtract to get [-1,1)
             // We can't convert to an open range directly, that would require
-            // substracting `3.0 - EPSILON`, which is not representable.
+            // subtracting `3.0 - EPSILON`, which is not representable.
             // It is possible with an extra step, but an open range does not
-            // seem neccesary for the ziggurat algorithm anyway.
+            // seem necessary for the ziggurat algorithm anyway.
             (bits >> 12).into_float_with_exponent(1) - 3.0
         } else {
-            // Convert to a value in the range [1,2) and substract to get (0,1)
+            // Convert to a value in the range [1,2) and subtract to get (0,1)
             (bits >> 12).into_float_with_exponent(0) - (1.0 - core::f64::EPSILON / 2.0)
         };
         let x = u * x_tab[i];

rand_hc/src/hc128.rs

@@ -142,7 +142,7 @@ impl BlockRngCore for Hc128Core {
         let dd = (cc + 16) % 512;
         let ee = cc.wrapping_sub(16) % 512;
         // These asserts let the compiler optimize out the bounds checks.
-        // Some of them may be superflous, and that's fine:
+        // Some of them may be superfluous, and that's fine:
         // they'll be optimized out if that's the case.
         assert!(ee + 15 < 512);
         assert!(cc + 15 < 512);
@@ -238,7 +238,7 @@ impl Hc128Core {
         let dd = (cc + 16) % 512;
         let ee = cc.wrapping_sub(16) % 512;
         // These asserts let the compiler optimize out the bounds checks.
-        // Some of them may be superflous, and that's fine:
+        // Some of them may be superfluous, and that's fine:
         // they'll be optimized out if that's the case.
         assert!(ee + 15 < 512);
         assert!(cc + 15 < 512);