Merge 0.5

src/deprecated.rs

@@ -249,11 +249,42 @@ impl SeedableRng for StdRng {
 impl CryptoRng for StdRng {}
 
 
-#[cfg(feature="std")]
+#[cfg(all(feature="std",
+          any(target_os = "linux", target_os = "android",
+              target_os = "netbsd",
+              target_os = "dragonfly",
+              target_os = "haiku",
+              target_os = "emscripten",
+              target_os = "solaris",
+              target_os = "cloudabi",
+              target_os = "macos", target_os = "ios",
+              target_os = "freebsd",
+              target_os = "openbsd", target_os = "bitrig",
+              target_os = "redox",
+              target_os = "fuchsia",
+              windows,
+              all(target_arch = "wasm32", feature = "stdweb")
+)))]
 #[derive(Clone, Debug)]
 #[deprecated(since="0.6.0", note="import with rand::rngs::OsRng instead")]
 pub struct OsRng(rngs::OsRng);
 
+#[cfg(all(feature="std",
+          any(target_os = "linux", target_os = "android",
+              target_os = "netbsd",
+              target_os = "dragonfly",
+              target_os = "haiku",
+              target_os = "emscripten",
+              target_os = "solaris",
+              target_os = "cloudabi",
+              target_os = "macos", target_os = "ios",
+              target_os = "freebsd",
+              target_os = "openbsd", target_os = "bitrig",
+              target_os = "redox",
+              target_os = "fuchsia",
+              windows,
+              all(target_arch = "wasm32", feature = "stdweb")
+)))]
 #[cfg(feature="std")]
 impl RngCore for OsRng {
     #[inline(always)]
@@ -277,13 +308,45 @@ impl RngCore for OsRng {
     }
 }
 
+#[cfg(all(feature="std",
+          any(target_os = "linux", target_os = "android",
+              target_os = "netbsd",
+              target_os = "dragonfly",
+              target_os = "haiku",
+              target_os = "emscripten",
+              target_os = "solaris",
+              target_os = "cloudabi",
+              target_os = "macos", target_os = "ios",
+              target_os = "freebsd",
+              target_os = "openbsd", target_os = "bitrig",
+              target_os = "redox",
+              target_os = "fuchsia",
+              windows,
+              all(target_arch = "wasm32", feature = "stdweb")
+)))]
 #[cfg(feature="std")]
 impl OsRng {
     pub fn new() -> Result<Self, Error> {
         rngs::OsRng::new().map(OsRng)
     }
 }
 
+#[cfg(all(feature="std",
+          any(target_os = "linux", target_os = "android",
+              target_os = "netbsd",
+              target_os = "dragonfly",
+              target_os = "haiku",
+              target_os = "emscripten",
+              target_os = "solaris",
+              target_os = "cloudabi",
+              target_os = "macos", target_os = "ios",
+              target_os = "freebsd",
+              target_os = "openbsd", target_os = "bitrig",
+              target_os = "redox",
+              target_os = "fuchsia",
+              windows,
+              all(target_arch = "wasm32", feature = "stdweb")
+)))]
 #[cfg(feature="std")]
 impl CryptoRng for OsRng {}
 
@@ -361,7 +424,7 @@ impl RngCore for JitterRng {
 }
 
 impl JitterRng {
-    #[cfg(feature="std")]
+    #[cfg(all(feature="std", not(target_arch = "wasm32")))]
     pub fn new() -> Result<JitterRng, rngs::TimerError> {
         rngs::JitterRng::new().map(JitterRng)
     }

src/distributions/exponential.rs

@@ -19,14 +19,14 @@ use distributions::{ziggurat, ziggurat_tables, Distribution};
 ///
 /// See `Exp` for the general exponential distribution.
 ///
-/// Implemented via the ZIGNOR variant[1] of the Ziggurat method. The
-/// exact description in the paper was adjusted to use tables for the
-/// exponential distribution rather than normal.
+/// Implemented via the ZIGNOR variant[^1] of the Ziggurat method. The exact
+/// description in the paper was adjusted to use tables for the exponential
+/// distribution rather than normal.
 ///
-/// [1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to
-/// Generate Normal Random
-/// Samples*](https://www.doornik.com/research/ziggurat.pdf). Nuffield
-/// College, Oxford
+/// [^1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to
+///       Generate Normal Random Samples*](
+///       https://www.doornik.com/research/ziggurat.pdf).
+///       Nuffield College, Oxford
 ///
 /// # Example
 /// ```
@@ -61,8 +61,8 @@ impl Distribution<f64> for Exp1 {
 
 /// The exponential distribution `Exp(lambda)`.
 ///
-/// This distribution has density function: `f(x) = lambda *
-/// exp(-lambda * x)` for `x > 0`.
+/// This distribution has density function: `f(x) = lambda * exp(-lambda * x)`
+/// for `x > 0`.
 ///
 /// # Example
 ///

src/distributions/gamma.rs

@@ -28,9 +28,9 @@ use distributions::{Distribution, Exp, Open01};
 /// where `Γ` is the Gamma function, `k` is the shape and `θ` is the
 /// scale and both `k` and `θ` are strictly positive.
 ///
-/// The algorithm used is that described by Marsaglia & Tsang 2000[1],
+/// The algorithm used is that described by Marsaglia & Tsang 2000[^1],
 /// falling back to directly sampling from an Exponential for `shape
-/// == 1`, and using the boosting technique described in [1] for
+/// == 1`, and using the boosting technique described in that paper for
 /// `shape < 1`.
 ///
 /// # Example
@@ -43,10 +43,10 @@ use distributions::{Distribution, Exp, Open01};
 /// println!("{} is from a Gamma(2, 5) distribution", v);
 /// ```
 ///
-/// [1]: George Marsaglia and Wai Wan Tsang. 2000. "A Simple Method
-/// for Generating Gamma Variables" *ACM Trans. Math. Softw.* 26, 3
-/// (September 2000),
-/// 363-372. DOI:[10.1145/358407.358414](https://doi.acm.org/10.1145/358407.358414)
+/// [^1]: George Marsaglia and Wai Wan Tsang. 2000. "A Simple Method for
+///       Generating Gamma Variables" *ACM Trans. Math. Softw.* 26, 3
+///       (September 2000), 363-372.
+///       DOI:[10.1145/358407.358414](https://doi.acm.org/10.1145/358407.358414)
 #[derive(Clone, Copy, Debug)]
 pub struct Gamma {
     repr: GammaRepr,

src/distributions/mod.rs

@@ -142,7 +142,6 @@
 //! [`Rng::gen_range`]: ../trait.Rng.html#method.gen_range
 //! [`Rng::gen()`]: ../trait.Rng.html#method.gen
 //! [`Rng`]: ../trait.Rng.html
-//! [`sample_iter`]: trait.Distribution.html#method.sample_iter
 //! [`uniform` module]: uniform/index.html
 //! [Floating point implementation]: struct.Standard.html#floating-point-implementation
 // distributions
@@ -166,6 +165,8 @@
 //! [`StandardNormal`]: struct.StandardNormal.html
 //! [`StudentT`]: struct.StudentT.html
 //! [`Uniform`]: struct.Uniform.html
+//! [`Uniform::new`]: struct.Uniform.html#method.new
+//! [`Uniform::new_inclusive`]: struct.Uniform.html#method.new_inclusive
 
 use Rng;
 
@@ -220,15 +221,18 @@ mod ziggurat_tables;
 use distributions::float::IntoFloat;
 
 /// Types (distributions) that can be used to create a random instance of `T`.
-/// 
+///
 /// It is possible to sample from a distribution through both the
-/// [`Distribution`] and [`Rng`] traits, via `distr.sample(&mut rng)` and
+/// `Distribution` and [`Rng`] traits, via `distr.sample(&mut rng)` and
 /// `rng.sample(distr)`. They also both offer the [`sample_iter`] method, which
 /// produces an iterator that samples from the distribution.
 ///
 /// All implementations are expected to be immutable; this has the significant
 /// advantage of not needing to consider thread safety, and for most
 /// distributions efficient state-less sampling algorithms are available.
+///
+/// [`Rng`]: ../trait.Rng.html
+/// [`sample_iter`]: trait.Distribution.html#method.sample_iter
 pub trait Distribution<T> {
     /// Generate a random value of `T`, using `rng` as the source of randomness.
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T;

src/distributions/normal.rs

@@ -14,17 +14,17 @@ use Rng;
 use distributions::{ziggurat, ziggurat_tables, Distribution, Open01};
 
 /// Samples floating-point numbers according to the normal distribution
-/// `N(0, 1)` (a.k.a.  a standard normal, or Gaussian). This is equivalent to
+/// `N(0, 1)` (a.k.a. a standard normal, or Gaussian). This is equivalent to
 /// `Normal::new(0.0, 1.0)` but faster.
 ///
 /// See `Normal` for the general normal distribution.
 ///
-/// Implemented via the ZIGNOR variant[1] of the Ziggurat method.
+/// Implemented via the ZIGNOR variant[^1] of the Ziggurat method.
 ///
-/// [1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to
-/// Generate Normal Random
-/// Samples*](https://www.doornik.com/research/ziggurat.pdf). Nuffield
-/// College, Oxford
+/// [^1]: Jurgen A. Doornik (2005). [*An Improved Ziggurat Method to
+///       Generate Normal Random Samples*](
+///       https://www.doornik.com/research/ziggurat.pdf).
+///       Nuffield College, Oxford
 ///
 /// # Example
 /// ```
@@ -74,8 +74,8 @@ impl Distribution<f64> for StandardNormal {
 
 /// The normal distribution `N(mean, std_dev**2)`.
 ///
-/// This uses the ZIGNOR variant of the Ziggurat method, see
-/// `StandardNormal` for more details.
+/// This uses the ZIGNOR variant of the Ziggurat method, see `StandardNormal`
+/// for more details.
 ///
 /// # Example
 ///
@@ -119,8 +119,8 @@ impl Distribution<f64> for Normal {
 
 /// The log-normal distribution `ln N(mean, std_dev**2)`.
 ///
-/// If `X` is log-normal distributed, then `ln(X)` is `N(mean,
-/// std_dev**2)` distributed.
+/// If `X` is log-normal distributed, then `ln(X)` is `N(mean, std_dev**2)`
+/// distributed.
 ///
 /// # Example
 ///

src/lib.rs

@@ -249,11 +249,16 @@ extern crate stdweb;
 extern crate rand_core;
 
 #[cfg(feature = "log")] #[macro_use] extern crate log;
+#[allow(unused)]
 #[cfg(not(feature = "log"))] macro_rules! trace { ($($x:tt)*) => () }
+#[allow(unused)]
 #[cfg(not(feature = "log"))] macro_rules! debug { ($($x:tt)*) => () }
+#[allow(unused)]
 #[cfg(not(feature = "log"))] macro_rules! info { ($($x:tt)*) => () }
+#[allow(unused)]
 #[cfg(not(feature = "log"))] macro_rules! warn { ($($x:tt)*) => () }
-#[cfg(all(feature="std", not(feature = "log")))] macro_rules! error { ($($x:tt)*) => () }
+#[allow(unused)]
+#[cfg(not(feature = "log"))] macro_rules! error { ($($x:tt)*) => () }
 
 
 // Re-exports from rand_core
@@ -279,7 +284,27 @@ pub mod seq;
 #[doc(hidden)] pub use deprecated::ReseedingRng;
 
 #[allow(deprecated)]
-#[cfg(feature="std")] #[doc(hidden)] pub use deprecated::{EntropyRng, OsRng};
+#[cfg(feature="std")] #[doc(hidden)] pub use deprecated::EntropyRng;
+
+#[allow(deprecated)]
+#[cfg(all(feature="std",
+          any(target_os = "linux", target_os = "android",
+              target_os = "netbsd",
+              target_os = "dragonfly",
+              target_os = "haiku",
+              target_os = "emscripten",
+              target_os = "solaris",
+              target_os = "cloudabi",
+              target_os = "macos", target_os = "ios",
+              target_os = "freebsd",
+              target_os = "openbsd", target_os = "bitrig",
+              target_os = "redox",
+              target_os = "fuchsia",
+              windows,
+              all(target_arch = "wasm32", feature = "stdweb")
+)))]
+#[doc(hidden)]
+pub use deprecated::OsRng;
 
 #[allow(deprecated)]
 #[doc(hidden)] pub use deprecated::{ChaChaRng, IsaacRng, Isaac64Rng, XorShiftRng};
@@ -294,7 +319,22 @@ pub mod jitter {
     pub use rngs::TimerError;
 }
 #[allow(deprecated)]
-#[cfg(feature="std")]
+#[cfg(all(feature="std",
+          any(target_os = "linux", target_os = "android",
+              target_os = "netbsd",
+              target_os = "dragonfly",
+              target_os = "haiku",
+              target_os = "emscripten",
+              target_os = "solaris",
+              target_os = "cloudabi",
+              target_os = "macos", target_os = "ios",
+              target_os = "freebsd",
+              target_os = "openbsd", target_os = "bitrig",
+              target_os = "redox",
+              target_os = "fuchsia",
+              windows,
+              all(target_arch = "wasm32", feature = "stdweb")
+)))]
 #[doc(hidden)]
 pub mod os {
     pub use deprecated::OsRng;

src/prng/chacha.rs

@@ -20,10 +20,10 @@ const STATE_WORDS: usize = 16;
 /// A cryptographically secure random number generator that uses the ChaCha
 /// algorithm.
 ///
-/// ChaCha is a stream cipher designed by Daniel J. Bernstein [1], that we use
+/// ChaCha is a stream cipher designed by Daniel J. Bernstein [^1], that we use
 /// as an RNG. It is an improved variant of the Salsa20 cipher family, which was
 /// selected as one of the "stream ciphers suitable for widespread adoption" by
-/// eSTREAM [2].
+/// eSTREAM [^2].
 ///
 /// ChaCha uses add-rotate-xor (ARX) operations as its basis. These are safe
 /// against timing attacks, although that is mostly a concern for ciphers and
@@ -39,7 +39,7 @@ const STATE_WORDS: usize = 16;
 /// configuration in the future.
 ///
 /// We use a 64-bit counter and 64-bit stream identifier as in Benstein's
-/// implementation [1] except that we use a stream identifier in place of a
+/// implementation [^1] except that we use a stream identifier in place of a
 /// nonce. A 64-bit counter over 64-byte (16 word) blocks allows 1 ZiB of output
 /// before cycling, and the stream identifier allows 2<sup>64</sup> unique
 /// streams of output per seed. Both counter and stream are initialized to zero
@@ -57,11 +57,11 @@ const STATE_WORDS: usize = 16;
 /// This implementation uses an output buffer of sixteen `u32` words, and uses
 /// [`BlockRng`] to implement the [`RngCore`] methods.
 ///
-/// [1]: D. J. Bernstein, [*ChaCha, a variant of Salsa20*](
-///      https://cr.yp.to/chacha.html)
+/// [^1]: D. J. Bernstein, [*ChaCha, a variant of Salsa20*](
+///       https://cr.yp.to/chacha.html)
 ///
-/// [2]: [eSTREAM: the ECRYPT Stream Cipher Project](
-///      http://www.ecrypt.eu.org/stream/)
+/// [^2]: [eSTREAM: the ECRYPT Stream Cipher Project](
+///       http://www.ecrypt.eu.org/stream/)
 ///
 /// [`set_word_pos`]: #method.set_word_pos
 /// [`set_stream`]: #method.set_stream