WIP

Author: pitdicker

src/lib.rs

@@ -446,6 +446,13 @@ pub trait Sample: Rng {
     fn iter<'a>(&'a mut self) -> iter::Iter<'a, Self> {
         iter(self)
     }
+
+    fn fill_slice<T>(&mut self, slice: &mut [T])
+    where [T]: FillSlice<T> + AsMut<[T]>,
+          Default: Distribution<T>,
+          Self: ::core::marker::Sized {
+        FillSlice::fill_slice(self, slice.as_mut());
+    }
 }
 
 impl<R: Rng+?Sized> Sample for R {
@@ -493,10 +500,59 @@ impl SeedableRng for StdRng {
 }
 
 
+
+pub trait FillSlice<T>: AsMut<[T]>
+where Default: Distribution<T> {
+    fn fill_slice<R: Rng>(rng: &mut R, slice: &mut Self) {
+        for i in slice.as_mut().iter_mut() {
+            *i = rng.gen()
+        }
+    }
+}
+
+macro_rules! impl_fill_slice {
+    ($ty:ty) => {
+        impl FillSlice<$ty> for [$ty] {
+            fn fill_slice<R: Rng>(rng: &mut R, slice: &mut Self) {
+                // Fill as if this is an `u8` array.
+                unsafe {
+                    // FIXME: are we violating pointer aliasing rules here?
+                    let len = slice.len() * ::core::mem::size_of::<$ty>();
+                    let ptr = slice.as_mut_ptr() as *mut u8;
+                    let slice_u8 = ::core::slice::from_raw_parts_mut(ptr, len);
+                    rng.fill_bytes(slice_u8);
+                }
+                // Fix endianness on Big-Endian architectures.
+                for i in slice.iter_mut() {
+                    *i = i.to_le();
+                }
+            }
+        }
+   }
+}
+
+impl_fill_slice! { i8 }
+impl_fill_slice! { i16 }
+impl_fill_slice! { i32 }
+impl_fill_slice! { i64 }
+#[cfg(feature = "i128_support")]
+impl_fill_slice! { i128 }
+impl_fill_slice! { isize }
+impl_fill_slice! { u8 }
+impl_fill_slice! { u16 }
+impl_fill_slice! { u32 }
+impl_fill_slice! { u64 }
+#[cfg(feature = "i128_support")]
+impl_fill_slice! { u128 }
+impl_fill_slice! { usize }
+
+
+
+
 #[cfg(test)]
 mod test {
     use {Rng, thread_rng, Sample, Error};
-    use mock::MockAddRng;   
+    use mock::MockAddRng;
     use distributions::{Uniform, Range, Exp};
     use sequences::Shuffle;
     use std::iter::repeat;
@@ -613,4 +669,13 @@ mod test {
 
         let _c = rng.sample(Exp::new(2.0));
     }
+
+    #[test]
+    fn test_fill_slice() {
+        use super::FillSlice;
+        let mut rng = thread_rng();
+        let mut array = [0u32; 100];
+        rng.fill_slice(&mut array[..]);
+        assert!(!array.iter().all(|&x| x == 0));
+    }
 }