Support run-time polymorphism of Rng in Distribution::sample

dhardy · dhardy · commit 869a29bf617d · 2018-02-19T16:02:36.000Z
diff --git a/src/distributions/exponential.rs b/src/distributions/exponential.rs
@@ -42,13 +42,13 @@ pub struct Exp1;
 // This could be done via `-rng.gen::<f64>().ln()` but that is slower.
 impl Distribution<f64> for Exp1 {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         #[inline]
         fn pdf(x: f64) -> f64 {
             (-x).exp()
         }
         #[inline]
-        fn zero_case<R:Rng>(rng: &mut R, _u: f64) -> f64 {
+        fn zero_case<R: Rng + ?Sized>(rng: &mut R, _u: f64) -> f64 {
             ziggurat_tables::ZIG_EXP_R - rng.gen::<f64>().ln()
         }
 
@@ -90,7 +90,7 @@ impl Exp {
 }
 
 impl Distribution<f64> for Exp {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         let n: f64 = rng.sample(Exp1);
         n * self.lambda_inverse
     }
diff --git a/src/distributions/float.rs b/src/distributions/float.rs
@@ -68,13 +68,13 @@ macro_rules! float_impls {
                 /// See `Closed01` for the closed interval `[0,1]`,
                 /// and `Open01` for the open interval `(0,1)`.
                 #[inline]
-                fn sample<R: Rng>(&self, rng: &mut R) -> $ty {
+                fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
                     rng.$method_name()
                 }
             }
             impl Distribution<$ty> for Open01 {
                 #[inline]
-                fn sample<R: Rng>(&self, rng: &mut R) -> $ty {
+                fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
                     // add 0.5 * epsilon, so that smallest number is
                     // greater than 0, and largest number is still
                     // less than 1, specifically 1 - 0.5 * epsilon.
@@ -83,7 +83,7 @@ macro_rules! float_impls {
             }
             impl Distribution<$ty> for Closed01 {
                 #[inline]
-                fn sample<R: Rng>(&self, rng: &mut R) -> $ty {
+                fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
                     // rescale so that 1.0 - epsilon becomes 1.0
                     // precisely.
                     rng.$method_name() * SCALE / (SCALE - 1.0)
diff --git a/src/distributions/gamma.rs b/src/distributions/gamma.rs
@@ -134,7 +134,7 @@ impl GammaLargeShape {
 }
 
 impl Distribution<f64> for Gamma {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         match self.repr {
             Small(ref g) => g.sample(rng),
             One(ref g) => g.sample(rng),
@@ -143,14 +143,14 @@ impl Distribution<f64> for Gamma {
     }
 }
 impl Distribution<f64> for GammaSmallShape {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         let u: f64 = rng.sample(Open01);
 
         self.large_shape.sample(rng) * u.powf(self.inv_shape)
     }
 }
 impl Distribution<f64> for GammaLargeShape {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         loop {
             let x = rng.sample(StandardNormal);
             let v_cbrt = 1.0 + self.c * x;
@@ -215,7 +215,7 @@ impl ChiSquared {
     }
 }
 impl Distribution<f64> for ChiSquared {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         match self.repr {
             DoFExactlyOne => {
                 // k == 1 => N(0,1)^2
@@ -266,7 +266,7 @@ impl FisherF {
     }
 }
 impl Distribution<f64> for FisherF {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         self.numer.sample(rng) / self.denom.sample(rng) * self.dof_ratio
     }
 }
@@ -301,7 +301,7 @@ impl StudentT {
     }
 }
 impl Distribution<f64> for StudentT {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         let norm = rng.sample(StandardNormal);
         norm * (self.dof / self.chi.sample(rng)).sqrt()
     }
diff --git a/src/distributions/integer.rs b/src/distributions/integer.rs
@@ -17,7 +17,7 @@ use distributions::{Distribution, Uniform};
 
 impl Distribution<isize> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> isize {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> isize {
         if mem::size_of::<isize>() == 4 {
             rng.gen::<i32>() as isize
         } else {
@@ -28,43 +28,43 @@ impl Distribution<isize> for Uniform {
 
 impl Distribution<i8> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> i8 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i8 {
         rng.next_u32() as i8
     }
 }
 
 impl Distribution<i16> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> i16 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i16 {
         rng.next_u32() as i16
     }
 }
 
 impl Distribution<i32> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> i32 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i32 {
         rng.next_u32() as i32
     }
 }
 
 impl Distribution<i64> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> i64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i64 {
         rng.next_u64() as i64
     }
 }
 
 #[cfg(feature = "i128_support")]
 impl Distribution<i128> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> i128 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i128 {
         rng.gen::<u128>() as i128
     }
 }
 
 impl Distribution<usize> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> usize {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize {
         if mem::size_of::<usize>() == 4 {
             rng.gen::<u32>() as usize
         } else {
@@ -75,36 +75,36 @@ impl Distribution<usize> for Uniform {
 
 impl Distribution<u8> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> u8 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
         rng.next_u32() as u8
     }
 }
 
 impl Distribution<u16> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> u16 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
         rng.next_u32() as u16
     }
 }
 
 impl Distribution<u32> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> u32 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
         rng.next_u32()
     }
 }
 
 impl Distribution<u64> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> u64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
         rng.next_u64()
     }
 }
 
 #[cfg(feature = "i128_support")]
 impl Distribution<u128> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> u128 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
         ((rng.next_u64() as u128) << 64) | (rng.next_u64() as u128)
     }
 }
diff --git a/src/distributions/mod.rs b/src/distributions/mod.rs
@@ -123,11 +123,11 @@ mod impls {
 pub trait Distribution<T> {
     /// Generate a random value of `T`, using `rng` as the
     /// source of randomness.
-    fn sample<R: Rng>(&self, rng: &mut R) -> T;
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T;
 }
 
 impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
-    fn sample<R: Rng>(&self, rng: &mut R) -> T {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T {
         (*self).sample(rng)
     }
 }
@@ -265,7 +265,7 @@ impl<'a, T: Clone> WeightedChoice<'a, T> {
 }
 
 impl<'a, T: Clone> Distribution<T> for WeightedChoice<'a, T> {
-    fn sample<R: Rng>(&self, rng: &mut R) -> T {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T {
         // we want to find the first element that has cumulative
         // weight > sample_weight, which we do by binary since the
         // cumulative weights of self.items are sorted.
@@ -324,7 +324,7 @@ impl<'a, T: Clone> Distribution<T> for WeightedChoice<'a, T> {
 // size from force-inlining.
 #[cfg(feature="std")]
 #[inline(always)]
-fn ziggurat<R: Rng, P, Z>(
+fn ziggurat<R: Rng + ?Sized, P, Z>(
             rng: &mut R,
             symmetric: bool,
             x_tab: ziggurat_tables::ZigTable,
diff --git a/src/distributions/normal.rs b/src/distributions/normal.rs
@@ -38,13 +38,13 @@ use distributions::{ziggurat, ziggurat_tables, Distribution, Open01};
 pub struct StandardNormal;
 
 impl Distribution<f64> for StandardNormal {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         #[inline]
         fn pdf(x: f64) -> f64 {
             (-x*x/2.0).exp()
         }
         #[inline]
-        fn zero_case<R:Rng>(rng: &mut R, u: f64) -> f64 {
+        fn zero_case<R: Rng + ?Sized>(rng: &mut R, u: f64) -> f64 {
             // compute a random number in the tail by hand
 
             // strange initial conditions, because the loop is not
@@ -110,7 +110,7 @@ impl Normal {
     }
 }
 impl Distribution<f64> for Normal {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         let n = rng.sample(StandardNormal);
         self.mean + self.std_dev * n
     }
@@ -151,7 +151,7 @@ impl LogNormal {
     }
 }
 impl Distribution<f64> for LogNormal {
-    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
         self.norm.sample(rng).exp()
     }
 }
diff --git a/src/distributions/other.rs b/src/distributions/other.rs
@@ -17,7 +17,7 @@ use distributions::{Distribution, Uniform};
 
 impl Distribution<char> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> char {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> char {
         // a char is 21 bits
         const CHAR_MASK: u32 = 0x001f_ffff;
         loop {
@@ -34,7 +34,7 @@ impl Distribution<char> for Uniform {
 
 impl Distribution<bool> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> bool {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> bool {
         rng.gen::<u8>() & 1 == 1
     }
 }
@@ -49,7 +49,7 @@ macro_rules! tuple_impl {
             where $( Uniform: Distribution<$tyvar> ),*
         {
             #[inline]
-            fn sample<R: Rng>(&self, _rng: &mut R) -> ( $( $tyvar ),* , ) {
+            fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> ( $( $tyvar ),* , ) {
                 (
                     // use the $tyvar's to get the appropriate number of
                     // repeats (they're not actually needed)
@@ -65,7 +65,7 @@ macro_rules! tuple_impl {
 
 impl Distribution<()> for Uniform {
     #[inline]
-    fn sample<R: Rng>(&self, _: &mut R) -> () { () }
+    fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> () { () }
 }
 tuple_impl!{A}
 tuple_impl!{A, B}
@@ -87,15 +87,15 @@ macro_rules! array_impl {
 
         impl<T> Distribution<[T; $n]> for Uniform where Uniform: Distribution<T> {
             #[inline]
-            fn sample<R: Rng>(&self, _rng: &mut R) -> [T; $n] {
+            fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> [T; $n] {
                 [_rng.gen::<$t>(), $(_rng.gen::<$ts>()),*]
             }
         }
     };
     // empty case:
     {$n:expr,} => {
         impl<T> Distribution<[T; $n]> for Uniform {
-            fn sample<R: Rng>(&self, _rng: &mut R) -> [T; $n] { [] }
+            fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> [T; $n] { [] }
         }
     };
 }
@@ -104,7 +104,7 @@ array_impl!{32, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T
 
 impl<T> Distribution<Option<T>> for Uniform where Uniform: Distribution<T> {
     #[inline]
-    fn sample<R: Rng>(&self, rng: &mut R) -> Option<T> {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<T> {
         // UFCS is needed here: https://github.com/rust-lang/rust/issues/24066
         if rng.gen::<bool>() {
             Some(rng.gen())
diff --git a/src/distributions/range.rs b/src/distributions/range.rs
@@ -63,7 +63,7 @@ impl<X: SampleRange + PartialOrd> Range<X> {
 }
 
 impl<Sup: SampleRange> Distribution<Sup> for Range<Sup> {
-    fn sample<R: Rng>(&self, rng: &mut R) -> Sup {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Sup {
         SampleRange::sample_range(self, rng)
     }
 }
@@ -80,7 +80,7 @@ pub trait SampleRange : Sized {
 
     /// Sample a value from the given `Range` with the given `Rng` as
     /// a source of randomness.
-    fn sample_range<R: Rng>(r: &Range<Self>, rng: &mut R) -> Self;
+    fn sample_range<R: Rng + ?Sized>(r: &Range<Self>, rng: &mut R) -> Self;
 }
 
 macro_rules! integer_impl {
@@ -111,7 +111,7 @@ macro_rules! integer_impl {
             }
 
             #[inline]
-            fn sample_range<R: Rng>(r: &Range<$ty>, rng: &mut R) -> $ty {
+            fn sample_range<R: Rng + ?Sized>(r: &Range<$ty>, rng: &mut R) -> $ty {
                 loop {
                     // rejection sample
                     let v = rng.gen::<$unsigned>();
@@ -153,7 +153,7 @@ macro_rules! float_impl {
                     accept_zone: 0.0 // unused
                 }
             }
-            fn sample_range<R: Rng>(r: &Range<$ty>, rng: &mut R) -> $ty {
+            fn sample_range<R: Rng + ?Sized>(r: &Range<$ty>, rng: &mut R) -> $ty {
                 r.low + r.range * rng.gen::<$ty>()
             }
         }
diff --git a/src/lib.rs b/src/lib.rs

Original file line number	Diff line number	Diff line change
`@@ -42,13 +42,13 @@ pub struct Exp1;`
`42`	`42`	// This could be done via `-rng.gen::<f64>().ln()` but that is slower.
`43`	`43`	`impl Distribution<f64> for Exp1 {`
`44`	`44`	`#[inline]`
`45`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`45`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`46`	`46`	`#[inline]`
`47`	`47`	`fn pdf(x: f64) -> f64 {`
`48`	`48`	`(-x).exp()`
`49`	`49`	`}`
`50`	`50`	`#[inline]`
`51`		`- fn zero_case<R:Rng>(rng: &mut R, _u: f64) -> f64 {`
	`51`	`+ fn zero_case<R: Rng + ?Sized>(rng: &mut R, _u: f64) -> f64 {`
`52`	`52`	`ziggurat_tables::ZIG_EXP_R - rng.gen::<f64>().ln()`
`53`	`53`	`}`
`54`	`54`
`@@ -90,7 +90,7 @@ impl Exp {`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`impl Distribution<f64> for Exp {`
`93`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`93`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`94`	`94`	`let n: f64 = rng.sample(Exp1);`
`95`	`95`	`n * self.lambda_inverse`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ impl GammaLargeShape {`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`impl Distribution<f64> for Gamma {`
`137`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`137`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`138`	`138`	`match self.repr {`
`139`	`139`	`Small(ref g) => g.sample(rng),`
`140`	`140`	`One(ref g) => g.sample(rng),`
`@@ -143,14 +143,14 @@ impl Distribution<f64> for Gamma {`
`143`	`143`	`}`
`144`	`144`	`}`
`145`	`145`	`impl Distribution<f64> for GammaSmallShape {`
`146`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`146`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`147`	`147`	`let u: f64 = rng.sample(Open01);`
`148`	`148`
`149`	`149`	`self.large_shape.sample(rng) * u.powf(self.inv_shape)`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`	`impl Distribution<f64> for GammaLargeShape {`
`153`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`153`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`154`	`154`	`loop {`
`155`	`155`	`let x = rng.sample(StandardNormal);`
`156`	`156`	`let v_cbrt = 1.0 + self.c * x;`
`@@ -215,7 +215,7 @@ impl ChiSquared {`
`215`	`215`	`}`
`216`	`216`	`}`
`217`	`217`	`impl Distribution<f64> for ChiSquared {`
`218`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`218`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`219`	`219`	`match self.repr {`
`220`	`220`	`DoFExactlyOne => {`
`221`	`221`	`// k == 1 => N(0,1)^2`
`@@ -266,7 +266,7 @@ impl FisherF {`
`266`	`266`	`}`
`267`	`267`	`}`
`268`	`268`	`impl Distribution<f64> for FisherF {`
`269`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`269`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`270`	`270`	`self.numer.sample(rng) / self.denom.sample(rng) * self.dof_ratio`
`271`	`271`	`}`
`272`	`272`	`}`
`@@ -301,7 +301,7 @@ impl StudentT {`
`301`	`301`	`}`
`302`	`302`	`}`
`303`	`303`	`impl Distribution<f64> for StudentT {`
`304`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`304`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`305`	`305`	`let norm = rng.sample(StandardNormal);`
`306`	`306`	`norm * (self.dof / self.chi.sample(rng)).sqrt()`
`307`	`307`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ use distributions::{Distribution, Uniform};`
`17`	`17`
`18`	`18`	`impl Distribution<isize> for Uniform {`
`19`	`19`	`#[inline]`
`20`		`- fn sample<R: Rng>(&self, rng: &mut R) -> isize {`
	`20`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> isize {`
`21`	`21`	`if mem::size_of::<isize>() == 4 {`
`22`	`22`	`rng.gen::<i32>() as isize`
`23`	`23`	`} else {`
`@@ -28,43 +28,43 @@ impl Distribution<isize> for Uniform {`
`28`	`28`
`29`	`29`	`impl Distribution<i8> for Uniform {`
`30`	`30`	`#[inline]`
`31`		`- fn sample<R: Rng>(&self, rng: &mut R) -> i8 {`
	`31`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i8 {`
`32`	`32`	`rng.next_u32() as i8`
`33`	`33`	`}`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`impl Distribution<i16> for Uniform {`
`37`	`37`	`#[inline]`
`38`		`- fn sample<R: Rng>(&self, rng: &mut R) -> i16 {`
	`38`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i16 {`
`39`	`39`	`rng.next_u32() as i16`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`impl Distribution<i32> for Uniform {`
`44`	`44`	`#[inline]`
`45`		`- fn sample<R: Rng>(&self, rng: &mut R) -> i32 {`
	`45`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i32 {`
`46`	`46`	`rng.next_u32() as i32`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`impl Distribution<i64> for Uniform {`
`51`	`51`	`#[inline]`
`52`		`- fn sample<R: Rng>(&self, rng: &mut R) -> i64 {`
	`52`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i64 {`
`53`	`53`	`rng.next_u64() as i64`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`#[cfg(feature = "i128_support")]`
`58`	`58`	`impl Distribution<i128> for Uniform {`
`59`	`59`	`#[inline]`
`60`		`- fn sample<R: Rng>(&self, rng: &mut R) -> i128 {`
	`60`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i128 {`
`61`	`61`	`rng.gen::<u128>() as i128`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`impl Distribution<usize> for Uniform {`
`66`	`66`	`#[inline]`
`67`		`- fn sample<R: Rng>(&self, rng: &mut R) -> usize {`
	`67`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize {`
`68`	`68`	`if mem::size_of::<usize>() == 4 {`
`69`	`69`	`rng.gen::<u32>() as usize`
`70`	`70`	`} else {`
`@@ -75,36 +75,36 @@ impl Distribution<usize> for Uniform {`
`75`	`75`
`76`	`76`	`impl Distribution<u8> for Uniform {`
`77`	`77`	`#[inline]`
`78`		`- fn sample<R: Rng>(&self, rng: &mut R) -> u8 {`
	`78`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {`
`79`	`79`	`rng.next_u32() as u8`
`80`	`80`	`}`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`impl Distribution<u16> for Uniform {`
`84`	`84`	`#[inline]`
`85`		`- fn sample<R: Rng>(&self, rng: &mut R) -> u16 {`
	`85`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {`
`86`	`86`	`rng.next_u32() as u16`
`87`	`87`	`}`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`impl Distribution<u32> for Uniform {`
`91`	`91`	`#[inline]`
`92`		`- fn sample<R: Rng>(&self, rng: &mut R) -> u32 {`
	`92`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {`
`93`	`93`	`rng.next_u32()`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`impl Distribution<u64> for Uniform {`
`98`	`98`	`#[inline]`
`99`		`- fn sample<R: Rng>(&self, rng: &mut R) -> u64 {`
	`99`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {`
`100`	`100`	`rng.next_u64()`
`101`	`101`	`}`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`#[cfg(feature = "i128_support")]`
`105`	`105`	`impl Distribution<u128> for Uniform {`
`106`	`106`	`#[inline]`
`107`		`- fn sample<R: Rng>(&self, rng: &mut R) -> u128 {`
	`107`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {`
`108`	`108`	`((rng.next_u64() as u128) << 64) \| (rng.next_u64() as u128)`
`109`	`109`	`}`
`110`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,13 +38,13 @@ use distributions::{ziggurat, ziggurat_tables, Distribution, Open01};`
`38`	`38`	`pub struct StandardNormal;`
`39`	`39`
`40`	`40`	`impl Distribution<f64> for StandardNormal {`
`41`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`41`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`42`	`42`	`#[inline]`
`43`	`43`	`fn pdf(x: f64) -> f64 {`
`44`	`44`	`(-x*x/2.0).exp()`
`45`	`45`	`}`
`46`	`46`	`#[inline]`
`47`		`- fn zero_case<R:Rng>(rng: &mut R, u: f64) -> f64 {`
	`47`	`+ fn zero_case<R: Rng + ?Sized>(rng: &mut R, u: f64) -> f64 {`
`48`	`48`	`// compute a random number in the tail by hand`
`49`	`49`
`50`	`50`	`// strange initial conditions, because the loop is not`
`@@ -110,7 +110,7 @@ impl Normal {`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`	`impl Distribution<f64> for Normal {`
`113`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`113`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`114`	`114`	`let n = rng.sample(StandardNormal);`
`115`	`115`	`self.mean + self.std_dev * n`
`116`	`116`	`}`
`@@ -151,7 +151,7 @@ impl LogNormal {`
`151`	`151`	`}`
`152`	`152`	`}`
`153`	`153`	`impl Distribution<f64> for LogNormal {`
`154`		`- fn sample<R: Rng>(&self, rng: &mut R) -> f64 {`
	`154`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {`
`155`	`155`	`self.norm.sample(rng).exp()`
`156`	`156`	`}`
`157`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ impl<X: SampleRange + PartialOrd> Range<X> {`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`impl<Sup: SampleRange> Distribution<Sup> for Range<Sup> {`
`66`		`- fn sample<R: Rng>(&self, rng: &mut R) -> Sup {`
	`66`	`+ fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Sup {`
`67`	`67`	`SampleRange::sample_range(self, rng)`
`68`	`68`	`}`
`69`	`69`	`}`
`@@ -80,7 +80,7 @@ pub trait SampleRange : Sized {`
`80`	`80`
`81`	`81`	/// Sample a value from the given `Range` with the given `Rng` as
`82`	`82`	`/// a source of randomness.`
`83`		`- fn sample_range<R: Rng>(r: &Range<Self>, rng: &mut R) -> Self;`
	`83`	`+ fn sample_range<R: Rng + ?Sized>(r: &Range<Self>, rng: &mut R) -> Self;`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`macro_rules! integer_impl {`
`@@ -111,7 +111,7 @@ macro_rules! integer_impl {`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`#[inline]`
`114`		`- fn sample_range<R: Rng>(r: &Range<$ty>, rng: &mut R) -> $ty {`
	`114`	`+ fn sample_range<R: Rng + ?Sized>(r: &Range<$ty>, rng: &mut R) -> $ty {`
`115`	`115`	`loop {`
`116`	`116`	`// rejection sample`
`117`	`117`	`let v = rng.gen::<$unsigned>();`
`@@ -153,7 +153,7 @@ macro_rules! float_impl {`
`153`	`153`	`accept_zone: 0.0 // unused`
`154`	`154`	`}`
`155`	`155`	`}`
`156`		`- fn sample_range<R: Rng>(r: &Range<$ty>, rng: &mut R) -> $ty {`
	`156`	`+ fn sample_range<R: Rng + ?Sized>(r: &Range<$ty>, rng: &mut R) -> $ty {`
`157`	`157`	`r.low + r.range * rng.gen::<$ty>()`
`158`	`158`	`}`
`159`	`159`	`}`