std: merge rand::{Rng,RngUtil} with default methods.
Also, documentation & general clean-up: - remove `gen_char_from`: better served by `sample` or `choose`. - `gen_bytes` generalised to `gen_vec`. - `gen_int_range`/`gen_uint_range` merged into `gen_integer_range` and made to be properly uniformly distributed. Fixes #8644. Minor adjustments to other functions.
This commit is contained in:
parent
884c1e112d
commit
fb923c7d3f
|
@ -311,11 +311,11 @@ mod test {
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_base64_random() {
|
fn test_base64_random() {
|
||||||
use std::rand::{task_rng, random, RngUtil};
|
use std::rand::{task_rng, random, Rng};
|
||||||
use std::vec;
|
use std::vec;
|
||||||
|
|
||||||
do 1000.times {
|
do 1000.times {
|
||||||
let times = task_rng().gen_uint_range(1, 100);
|
let times = task_rng().gen_integer_range(1u, 100);
|
||||||
let v = vec::from_fn(times, |_| random::<u8>());
|
let v = vec::from_fn(times, |_| random::<u8>());
|
||||||
assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
|
assert_eq!(v.to_base64(STANDARD).from_base64().unwrap(), v);
|
||||||
}
|
}
|
||||||
|
|
|
@ -43,7 +43,7 @@ pub trait Deque<T> : Mutable {
|
||||||
mod bench {
|
mod bench {
|
||||||
use std::container::MutableMap;
|
use std::container::MutableMap;
|
||||||
use std::{vec, rand};
|
use std::{vec, rand};
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
use test::BenchHarness;
|
use test::BenchHarness;
|
||||||
|
|
||||||
pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
|
pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
|
||||||
|
|
|
@ -347,8 +347,7 @@ impl <T: FixedBuffer> StandardPadding for T {
|
||||||
|
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod test {
|
mod test {
|
||||||
use std::rand::IsaacRng;
|
use std::rand::{IsaacRng, Rng};
|
||||||
use std::rand::RngUtil;
|
|
||||||
use std::vec;
|
use std::vec;
|
||||||
|
|
||||||
use cryptoutil::{add_bytes_to_bits, add_bytes_to_bits_tuple};
|
use cryptoutil::{add_bytes_to_bits, add_bytes_to_bits_tuple};
|
||||||
|
@ -365,7 +364,7 @@ mod test {
|
||||||
digest.reset();
|
digest.reset();
|
||||||
|
|
||||||
while count < total_size {
|
while count < total_size {
|
||||||
let next: uint = rng.gen_uint_range(0, 2 * blocksize + 1);
|
let next: uint = rng.gen_integer_range(0, 2 * blocksize + 1);
|
||||||
let remaining = total_size - count;
|
let remaining = total_size - count;
|
||||||
let size = if next > remaining { remaining } else { next };
|
let size = if next > remaining { remaining } else { next };
|
||||||
digest.input(buffer.slice_to(size));
|
digest.input(buffer.slice_to(size));
|
||||||
|
|
|
@ -106,15 +106,15 @@ pub fn inflate_bytes_zlib(bytes: &[u8]) -> ~[u8] {
|
||||||
mod tests {
|
mod tests {
|
||||||
use super::*;
|
use super::*;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_flate_round_trip() {
|
fn test_flate_round_trip() {
|
||||||
let mut r = rand::rng();
|
let mut r = rand::rng();
|
||||||
let mut words = ~[];
|
let mut words = ~[];
|
||||||
do 20.times {
|
do 20.times {
|
||||||
let range = r.gen_uint_range(1, 10);
|
let range = r.gen_integer_range(1u, 10);
|
||||||
words.push(r.gen_bytes(range));
|
words.push(r.gen_vec::<u8>(range));
|
||||||
}
|
}
|
||||||
do 20.times {
|
do 20.times {
|
||||||
let mut input = ~[];
|
let mut input = ~[];
|
||||||
|
|
|
@ -23,7 +23,7 @@ use std::cmp::{Eq, Ord, TotalEq, TotalOrd, Ordering, Less, Equal, Greater};
|
||||||
use std::int;
|
use std::int;
|
||||||
use std::num;
|
use std::num;
|
||||||
use std::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix, Orderable};
|
use std::num::{IntConvertible, Zero, One, ToStrRadix, FromStrRadix, Orderable};
|
||||||
use std::rand::{Rng, RngUtil};
|
use std::rand::Rng;
|
||||||
use std::str;
|
use std::str;
|
||||||
use std::uint;
|
use std::uint;
|
||||||
use std::vec;
|
use std::vec;
|
||||||
|
|
|
@ -909,7 +909,7 @@ mod tests {
|
||||||
mod test_tim_sort {
|
mod test_tim_sort {
|
||||||
|
|
||||||
use sort::tim_sort;
|
use sort::tim_sort;
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
use std::vec;
|
use std::vec;
|
||||||
|
|
||||||
|
@ -1008,7 +1008,7 @@ mod big_tests {
|
||||||
|
|
||||||
use sort::*;
|
use sort::*;
|
||||||
|
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
use std::vec;
|
use std::vec;
|
||||||
|
|
||||||
|
@ -1069,8 +1069,8 @@ mod big_tests {
|
||||||
isSorted(arr);
|
isSorted(arr);
|
||||||
|
|
||||||
do 3.times {
|
do 3.times {
|
||||||
let i1 = rng.gen_uint_range(0, n);
|
let i1 = rng.gen_integer_range(0u, n);
|
||||||
let i2 = rng.gen_uint_range(0, n);
|
let i2 = rng.gen_integer_range(0u, n);
|
||||||
arr.swap(i1, i2);
|
arr.swap(i1, i2);
|
||||||
}
|
}
|
||||||
tim_sort(arr); // 3sort
|
tim_sort(arr); // 3sort
|
||||||
|
@ -1088,7 +1088,7 @@ mod big_tests {
|
||||||
isSorted(arr);
|
isSorted(arr);
|
||||||
|
|
||||||
do (n/100).times {
|
do (n/100).times {
|
||||||
let idx = rng.gen_uint_range(0, n);
|
let idx = rng.gen_integer_range(0u, n);
|
||||||
arr[idx] = rng.gen();
|
arr[idx] = rng.gen();
|
||||||
}
|
}
|
||||||
tim_sort(arr);
|
tim_sort(arr);
|
||||||
|
@ -1141,8 +1141,8 @@ mod big_tests {
|
||||||
isSorted(arr);
|
isSorted(arr);
|
||||||
|
|
||||||
do 3.times {
|
do 3.times {
|
||||||
let i1 = rng.gen_uint_range(0, n);
|
let i1 = rng.gen_integer_range(0u, n);
|
||||||
let i2 = rng.gen_uint_range(0, n);
|
let i2 = rng.gen_integer_range(0u, n);
|
||||||
arr.swap(i1, i2);
|
arr.swap(i1, i2);
|
||||||
}
|
}
|
||||||
tim_sort(arr); // 3sort
|
tim_sort(arr); // 3sort
|
||||||
|
@ -1160,7 +1160,7 @@ mod big_tests {
|
||||||
isSorted(arr);
|
isSorted(arr);
|
||||||
|
|
||||||
do (n/100).times {
|
do (n/100).times {
|
||||||
let idx = rng.gen_uint_range(0, n);
|
let idx = rng.gen_integer_range(0u, n);
|
||||||
arr[idx] = @rng.gen();
|
arr[idx] = @rng.gen();
|
||||||
}
|
}
|
||||||
tim_sort(arr);
|
tim_sort(arr);
|
||||||
|
|
|
@ -12,7 +12,7 @@
|
||||||
|
|
||||||
|
|
||||||
use std::os;
|
use std::os;
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
|
|
||||||
/// Attempts to make a temporary directory inside of `tmpdir` whose name will
|
/// Attempts to make a temporary directory inside of `tmpdir` whose name will
|
||||||
|
@ -20,7 +20,7 @@ use std::rand;
|
||||||
pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
|
pub fn mkdtemp(tmpdir: &Path, suffix: &str) -> Option<Path> {
|
||||||
let mut r = rand::rng();
|
let mut r = rand::rng();
|
||||||
for _ in range(0u, 1000) {
|
for _ in range(0u, 1000) {
|
||||||
let p = tmpdir.push(r.gen_str(16) + suffix);
|
let p = tmpdir.push(r.gen_ascii_str(16) + suffix);
|
||||||
if os::make_dir(&p, 0x1c0) { // 700
|
if os::make_dir(&p, 0x1c0) { // 700
|
||||||
return Some(p);
|
return Some(p);
|
||||||
}
|
}
|
||||||
|
|
|
@ -874,7 +874,7 @@ mod test_treemap {
|
||||||
|
|
||||||
use super::*;
|
use super::*;
|
||||||
|
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -1028,7 +1028,7 @@ mod test_treemap {
|
||||||
}
|
}
|
||||||
|
|
||||||
do 30.times {
|
do 30.times {
|
||||||
let r = rng.gen_uint_range(0, ctrl.len());
|
let r = rng.gen_integer_range(0, ctrl.len());
|
||||||
let (key, _) = ctrl.remove(r);
|
let (key, _) = ctrl.remove(r);
|
||||||
assert!(map.remove(&key));
|
assert!(map.remove(&key));
|
||||||
check_structure(&map);
|
check_structure(&map);
|
||||||
|
|
|
@ -62,7 +62,7 @@ use std::char::Char;
|
||||||
use std::container::Container;
|
use std::container::Container;
|
||||||
use std::to_str::ToStr;
|
use std::to_str::ToStr;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
use std::cmp::Eq;
|
use std::cmp::Eq;
|
||||||
use std::cast::{transmute,transmute_copy};
|
use std::cast::{transmute,transmute_copy};
|
||||||
|
|
||||||
|
@ -170,7 +170,7 @@ impl Uuid {
|
||||||
/// of random numbers. Use the rand::Rand trait to supply
|
/// of random numbers. Use the rand::Rand trait to supply
|
||||||
/// a custom generator if required.
|
/// a custom generator if required.
|
||||||
pub fn new_v4() -> Uuid {
|
pub fn new_v4() -> Uuid {
|
||||||
let ub = rand::task_rng().gen_bytes(16);
|
let ub = rand::task_rng().gen_vec(16);
|
||||||
let mut uuid = Uuid{ bytes: [0, .. 16] };
|
let mut uuid = Uuid{ bytes: [0, .. 16] };
|
||||||
vec::bytes::copy_memory(uuid.bytes, ub, 16);
|
vec::bytes::copy_memory(uuid.bytes, ub, 16);
|
||||||
uuid.set_variant(VariantRFC4122);
|
uuid.set_variant(VariantRFC4122);
|
||||||
|
@ -488,7 +488,7 @@ impl TotalEq for Uuid {
|
||||||
impl rand::Rand for Uuid {
|
impl rand::Rand for Uuid {
|
||||||
#[inline]
|
#[inline]
|
||||||
fn rand<R: rand::Rng>(rng: &mut R) -> Uuid {
|
fn rand<R: rand::Rng>(rng: &mut R) -> Uuid {
|
||||||
let ub = rng.gen_bytes(16);
|
let ub = rng.gen_vec(16);
|
||||||
let mut uuid = Uuid{ bytes: [0, .. 16] };
|
let mut uuid = Uuid{ bytes: [0, .. 16] };
|
||||||
vec::bytes::copy_memory(uuid.bytes, ub, 16);
|
vec::bytes::copy_memory(uuid.bytes, ub, 16);
|
||||||
uuid.set_variant(VariantRFC4122);
|
uuid.set_variant(VariantRFC4122);
|
||||||
|
|
|
@ -24,7 +24,7 @@ use iter::{Iterator, FromIterator, Extendable};
|
||||||
use iter::{FilterMap, Chain, Repeat, Zip};
|
use iter::{FilterMap, Chain, Repeat, Zip};
|
||||||
use num;
|
use num;
|
||||||
use option::{None, Option, Some};
|
use option::{None, Option, Some};
|
||||||
use rand::RngUtil;
|
use rand::Rng;
|
||||||
use rand;
|
use rand;
|
||||||
use uint;
|
use uint;
|
||||||
use util::replace;
|
use util::replace;
|
||||||
|
|
|
@ -734,7 +734,7 @@ mod test {
|
||||||
#[cfg(test)]
|
#[cfg(test)]
|
||||||
mod bench {
|
mod bench {
|
||||||
use extra::test::BenchHarness;
|
use extra::test::BenchHarness;
|
||||||
use rand::{XorShiftRng,RngUtil};
|
use rand::{XorShiftRng, Rng};
|
||||||
use float;
|
use float;
|
||||||
use to_str::ToStr;
|
use to_str::ToStr;
|
||||||
|
|
||||||
|
|
|
@ -1718,7 +1718,7 @@ mod tests {
|
||||||
use os::{remove_file, setenv, unsetenv};
|
use os::{remove_file, setenv, unsetenv};
|
||||||
use os;
|
use os;
|
||||||
use path::Path;
|
use path::Path;
|
||||||
use rand::RngUtil;
|
use rand::Rng;
|
||||||
use rand;
|
use rand;
|
||||||
use run;
|
use run;
|
||||||
use str::StrSlice;
|
use str::StrSlice;
|
||||||
|
@ -1738,7 +1738,7 @@ mod tests {
|
||||||
|
|
||||||
fn make_rand_name() -> ~str {
|
fn make_rand_name() -> ~str {
|
||||||
let mut rng = rand::rng();
|
let mut rng = rand::rng();
|
||||||
let n = ~"TEST" + rng.gen_str(10u);
|
let n = ~"TEST" + rng.gen_ascii_str(10u);
|
||||||
assert!(getenv(n).is_none());
|
assert!(getenv(n).is_none());
|
||||||
n
|
n
|
||||||
}
|
}
|
||||||
|
|
|
@ -11,7 +11,7 @@
|
||||||
/*!
|
/*!
|
||||||
Random number generation.
|
Random number generation.
|
||||||
|
|
||||||
The key functions are `random()` and `RngUtil::gen()`. These are polymorphic
|
The key functions are `random()` and `Rng::gen()`. These are polymorphic
|
||||||
and so can be used to generate any type that implements `Rand`. Type inference
|
and so can be used to generate any type that implements `Rand`. Type inference
|
||||||
means that often a simple call to `rand::random()` or `rng.gen()` will
|
means that often a simple call to `rand::random()` or `rng.gen()` will
|
||||||
suffice, but sometimes an annotation is required, e.g. `rand::random::<float>()`.
|
suffice, but sometimes an annotation is required, e.g. `rand::random::<float>()`.
|
||||||
|
@ -23,7 +23,7 @@ distributions like normal and exponential.
|
||||||
|
|
||||||
~~~ {.rust}
|
~~~ {.rust}
|
||||||
use std::rand;
|
use std::rand;
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
let mut rng = rand::rng();
|
let mut rng = rand::rng();
|
||||||
|
@ -44,17 +44,16 @@ fn main () {
|
||||||
*/
|
*/
|
||||||
|
|
||||||
use cast;
|
use cast;
|
||||||
use clone::Clone;
|
|
||||||
use cmp;
|
use cmp;
|
||||||
use container::Container;
|
use container::Container;
|
||||||
use int;
|
use int;
|
||||||
use iter::{Iterator, range, range_step};
|
use iter::{Iterator, range, range_step};
|
||||||
use local_data;
|
use local_data;
|
||||||
use num;
|
|
||||||
use prelude::*;
|
use prelude::*;
|
||||||
use str;
|
use str;
|
||||||
use sys;
|
use sys;
|
||||||
use u32;
|
use u32;
|
||||||
|
use u64;
|
||||||
use uint;
|
use uint;
|
||||||
use vec;
|
use vec;
|
||||||
use libc::size_t;
|
use libc::size_t;
|
||||||
|
@ -248,12 +247,6 @@ pub mod rustrt {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// A random number generator
|
|
||||||
pub trait Rng {
|
|
||||||
/// Return the next random integer
|
|
||||||
fn next(&mut self) -> u32;
|
|
||||||
}
|
|
||||||
|
|
||||||
/// A value with a particular weight compared to other values
|
/// A value with a particular weight compared to other values
|
||||||
pub struct Weighted<T> {
|
pub struct Weighted<T> {
|
||||||
/// The numerical weight of this item
|
/// The numerical weight of this item
|
||||||
|
@ -262,311 +255,187 @@ pub struct Weighted<T> {
|
||||||
item: T,
|
item: T,
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Helper functions attached to the Rng type
|
/// A random number generator
|
||||||
pub trait RngUtil {
|
pub trait Rng {
|
||||||
/// Return a random value of a Rand type
|
/// Return the next random integer
|
||||||
fn gen<T:Rand>(&mut self) -> T;
|
fn next(&mut self) -> u32;
|
||||||
/**
|
|
||||||
* Return a int randomly chosen from the range [start, end),
|
|
||||||
* failing if start >= end
|
|
||||||
*/
|
|
||||||
fn gen_int_range(&mut self, start: int, end: int) -> int;
|
|
||||||
/**
|
|
||||||
* Return a uint randomly chosen from the range [start, end),
|
|
||||||
* failing if start >= end
|
|
||||||
*/
|
|
||||||
fn gen_uint_range(&mut self, start: uint, end: uint) -> uint;
|
|
||||||
/**
|
|
||||||
* Return a char randomly chosen from chars, failing if chars is empty
|
|
||||||
*/
|
|
||||||
fn gen_char_from(&mut self, chars: &str) -> char;
|
|
||||||
/**
|
|
||||||
* Return a bool with a 1 in n chance of true
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* printfln!("%b", rng.gen_weighted_bool(3));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn gen_weighted_bool(&mut self, n: uint) -> bool;
|
|
||||||
/**
|
|
||||||
* Return a random string of the specified length composed of A-Z,a-z,0-9
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* println(rng.gen_str(8));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn gen_str(&mut self, len: uint) -> ~str;
|
|
||||||
/**
|
|
||||||
* Return a random byte string of the specified length
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* printfln!(rng.gen_bytes(8));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn gen_bytes(&mut self, len: uint) -> ~[u8];
|
|
||||||
/**
|
|
||||||
* Choose an item randomly, failing if values is empty
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* printfln!("%d", rng.choose([1,2,4,8,16,32]));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn choose<T:Clone>(&mut self, values: &[T]) -> T;
|
|
||||||
/// Choose Some(item) randomly, returning None if values is empty
|
|
||||||
fn choose_option<T:Clone>(&mut self, values: &[T]) -> Option<T>;
|
|
||||||
/**
|
|
||||||
* Choose an item respecting the relative weights, failing if the sum of
|
|
||||||
* the weights is 0
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* let x = [rand::Weighted {weight: 4, item: 'a'},
|
|
||||||
* rand::Weighted {weight: 2, item: 'b'},
|
|
||||||
* rand::Weighted {weight: 2, item: 'c'}];
|
|
||||||
* printfln!("%c", rng.choose_weighted(x));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn choose_weighted<T:Clone>(&mut self, v : &[Weighted<T>]) -> T;
|
|
||||||
/**
|
|
||||||
* Choose Some(item) respecting the relative weights, returning none if
|
|
||||||
* the sum of the weights is 0
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* let x = [rand::Weighted {weight: 4, item: 'a'},
|
|
||||||
* rand::Weighted {weight: 2, item: 'b'},
|
|
||||||
* rand::Weighted {weight: 2, item: 'c'}];
|
|
||||||
* printfln!(rng.choose_weighted_option(x));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
|
|
||||||
-> Option<T>;
|
|
||||||
/**
|
|
||||||
* Return a vec containing copies of the items, in order, where
|
|
||||||
* the weight of the item determines how many copies there are
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* let x = [rand::Weighted {weight: 4, item: 'a'},
|
|
||||||
* rand::Weighted {weight: 2, item: 'b'},
|
|
||||||
* rand::Weighted {weight: 2, item: 'c'}];
|
|
||||||
* printfln!(rng.weighted_vec(x));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T];
|
|
||||||
/**
|
|
||||||
* Shuffle a vec
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* printfln!(rng.shuffle([1,2,3]));
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn shuffle<T:Clone>(&mut self, values: &[T]) -> ~[T];
|
|
||||||
/**
|
|
||||||
* Shuffle a mutable vec in place
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* let mut y = [1,2,3];
|
|
||||||
* rng.shuffle_mut(y);
|
|
||||||
* printfln!(y);
|
|
||||||
* rng.shuffle_mut(y);
|
|
||||||
* printfln!(y);
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn shuffle_mut<T>(&mut self, values: &mut [T]);
|
|
||||||
|
|
||||||
/**
|
|
||||||
* Sample up to `n` values from an iterator.
|
|
||||||
*
|
|
||||||
* # Example
|
|
||||||
*
|
|
||||||
* ~~~ {.rust}
|
|
||||||
*
|
|
||||||
* use std::rand;
|
|
||||||
* use std::rand::RngUtil;
|
|
||||||
*
|
|
||||||
* fn main() {
|
|
||||||
* let mut rng = rand::rng();
|
|
||||||
* let vals = range(1, 100).to_owned_vec();
|
|
||||||
* let sample = rng.sample(vals.iter(), 5);
|
|
||||||
* printfln!(sample);
|
|
||||||
* }
|
|
||||||
* ~~~
|
|
||||||
*/
|
|
||||||
fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A];
|
|
||||||
}
|
|
||||||
|
|
||||||
/// Extension methods for random number generators
|
/// Return a random value of a Rand type.
|
||||||
impl<R: Rng> RngUtil for R {
|
///
|
||||||
/// Return a random value for a Rand type
|
/// # Example
|
||||||
#[inline]
|
///
|
||||||
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// let rng = rand::task_rng();
|
||||||
|
/// let x: uint = rng.gen();
|
||||||
|
/// printfln!(x);
|
||||||
|
/// printfln!(rng.gen::<(float, bool)>());
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
|
#[inline(always)]
|
||||||
fn gen<T: Rand>(&mut self) -> T {
|
fn gen<T: Rand>(&mut self) -> T {
|
||||||
Rand::rand(self)
|
Rand::rand(self)
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/// Return a random vector of the specified length.
|
||||||
* Return an int randomly chosen from the range [start, end),
|
///
|
||||||
* failing if start >= end
|
/// # Example
|
||||||
*/
|
///
|
||||||
fn gen_int_range(&mut self, start: int, end: int) -> int {
|
/// ~~~ {.rust}
|
||||||
assert!(start < end);
|
/// use std::rand;
|
||||||
start + num::abs(self.gen::<int>() % (end - start))
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// let rng = rand::task_rng();
|
||||||
|
/// let x: ~[uint] = rng.gen_vec(10);
|
||||||
|
/// printfln!(x);
|
||||||
|
/// printfln!(rng.gen_vec::<(float, bool)>(5));
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
|
fn gen_vec<T: Rand>(&mut self, len: uint) -> ~[T] {
|
||||||
|
vec::from_fn(len, |_| self.gen())
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/// Generate a random primitive integer in the range [`low`,
|
||||||
* Return a uint randomly chosen from the range [start, end),
|
/// `high`). Fails if `low >= high`.
|
||||||
* failing if start >= end
|
///
|
||||||
*/
|
/// This gives a uniform distribution (assuming this RNG is itself
|
||||||
fn gen_uint_range(&mut self, start: uint, end: uint) -> uint {
|
/// uniform), even for edge cases like `gen_integer_range(0u8,
|
||||||
assert!(start < end);
|
/// 170)`, which a naive modulo operation would return numbers
|
||||||
start + (self.gen::<uint>() % (end - start))
|
/// less than 85 with double the probability to those greater than
|
||||||
}
|
/// 85.
|
||||||
|
///
|
||||||
/**
|
/// # Example
|
||||||
* Return a char randomly chosen from chars, failing if chars is empty
|
///
|
||||||
*/
|
/// ~~~ {.rust}
|
||||||
fn gen_char_from(&mut self, chars: &str) -> char {
|
/// use std::rand;
|
||||||
assert!(!chars.is_empty());
|
///
|
||||||
let mut cs = ~[];
|
/// fn main() {
|
||||||
for c in chars.iter() { cs.push(c) }
|
/// let rng = rand::task_rng();
|
||||||
self.choose(cs)
|
/// let n: uint = rng.gen_integer_range(0u, 10);
|
||||||
}
|
/// printfln!(n);
|
||||||
|
/// let m: i16 = rng.gen_integer_range(-40, 400);
|
||||||
/// Return a bool with a 1-in-n chance of true
|
/// printfln!(m);
|
||||||
fn gen_weighted_bool(&mut self, n: uint) -> bool {
|
/// }
|
||||||
if n == 0u {
|
/// ~~~
|
||||||
true
|
fn gen_integer_range<T: Rand + Int>(&mut self, low: T, high: T) -> T {
|
||||||
} else {
|
assert!(low < high, "RNG.gen_integer_range called with low >= high");
|
||||||
self.gen_uint_range(1u, n + 1u) == 1u
|
let range = (high - low).to_u64();
|
||||||
|
let accept_zone = u64::max_value - u64::max_value % range;
|
||||||
|
loop {
|
||||||
|
let rand = self.gen::<u64>();
|
||||||
|
if rand < accept_zone {
|
||||||
|
return low + NumCast::from(rand % range);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/// Return a bool with a 1 in n chance of true
|
||||||
* Return a random string of the specified length composed of A-Z,a-z,0-9
|
///
|
||||||
*/
|
/// # Example
|
||||||
fn gen_str(&mut self, len: uint) -> ~str {
|
///
|
||||||
let charset = ~"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
|
/// ~~~ {.rust}
|
||||||
abcdefghijklmnopqrstuvwxyz\
|
/// use std::rand;
|
||||||
0123456789";
|
/// use std::rand::Rng;
|
||||||
let mut s = ~"";
|
///
|
||||||
let mut i = 0u;
|
/// fn main() {
|
||||||
while (i < len) {
|
/// let mut rng = rand::rng();
|
||||||
s = s + str::from_char(self.gen_char_from(charset));
|
/// printfln!("%b", rng.gen_weighted_bool(3));
|
||||||
i += 1u;
|
/// }
|
||||||
|
/// ~~~
|
||||||
|
fn gen_weighted_bool(&mut self, n: uint) -> bool {
|
||||||
|
n == 0 || self.gen_integer_range(0, n) == 0
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return a random string of the specified length composed of
|
||||||
|
/// A-Z,a-z,0-9.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// println(rand::task_rng().gen_ascii_str(10));
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
|
fn gen_ascii_str(&mut self, len: uint) -> ~str {
|
||||||
|
static GEN_ASCII_STR_CHARSET: &'static [u8] = bytes!("ABCDEFGHIJKLMNOPQRSTUVWXYZ\
|
||||||
|
abcdefghijklmnopqrstuvwxyz\
|
||||||
|
0123456789");
|
||||||
|
let mut s = str::with_capacity(len);
|
||||||
|
for _ in range(0, len) {
|
||||||
|
s.push_char(self.choose(GEN_ASCII_STR_CHARSET) as char)
|
||||||
}
|
}
|
||||||
s
|
s
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Return a random byte string of the specified length
|
/// Choose an item randomly, failing if `values` is empty.
|
||||||
fn gen_bytes(&mut self, len: uint) -> ~[u8] {
|
fn choose<T: Clone>(&mut self, values: &[T]) -> T {
|
||||||
do vec::from_fn(len) |_i| {
|
self.choose_option(values).expect("Rng.choose: `values` is empty").clone()
|
||||||
self.gen()
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Choose an item randomly, failing if values is empty
|
/// Choose `Some(&item)` randomly, returning `None` if values is
|
||||||
fn choose<T:Clone>(&mut self, values: &[T]) -> T {
|
/// empty.
|
||||||
self.choose_option(values).unwrap()
|
///
|
||||||
}
|
/// # Example
|
||||||
|
///
|
||||||
/// Choose Some(item) randomly, returning None if values is empty
|
/// ~~~ {.rust}
|
||||||
fn choose_option<T:Clone>(&mut self, values: &[T]) -> Option<T> {
|
/// use std::rand;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// printfln!(rand::task_rng().choose_option([1,2,4,8,16,32]));
|
||||||
|
/// printfln!(rand::task_rng().choose_option([]));
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
|
fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
|
||||||
if values.is_empty() {
|
if values.is_empty() {
|
||||||
None
|
None
|
||||||
} else {
|
} else {
|
||||||
Some(values[self.gen_uint_range(0u, values.len())].clone())
|
Some(&values[self.gen_integer_range(0u, values.len())])
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
/**
|
|
||||||
* Choose an item respecting the relative weights, failing if the sum of
|
/// Choose an item respecting the relative weights, failing if the sum of
|
||||||
* the weights is 0
|
/// the weights is 0
|
||||||
*/
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
/// use std::rand::Rng;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// let mut rng = rand::rng();
|
||||||
|
/// let x = [rand::Weighted {weight: 4, item: 'a'},
|
||||||
|
/// rand::Weighted {weight: 2, item: 'b'},
|
||||||
|
/// rand::Weighted {weight: 2, item: 'c'}];
|
||||||
|
/// printfln!("%c", rng.choose_weighted(x));
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
|
fn choose_weighted<T:Clone>(&mut self, v: &[Weighted<T>]) -> T {
|
||||||
self.choose_weighted_option(v).unwrap()
|
self.choose_weighted_option(v).expect("Rng.choose_weighted: total weight is 0")
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/// Choose Some(item) respecting the relative weights, returning none if
|
||||||
* Choose Some(item) respecting the relative weights, returning none if
|
/// the sum of the weights is 0
|
||||||
* the sum of the weights is 0
|
///
|
||||||
*/
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
/// use std::rand::Rng;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// let mut rng = rand::rng();
|
||||||
|
/// let x = [rand::Weighted {weight: 4, item: 'a'},
|
||||||
|
/// rand::Weighted {weight: 2, item: 'b'},
|
||||||
|
/// rand::Weighted {weight: 2, item: 'c'}];
|
||||||
|
/// printfln!(rng.choose_weighted_option(x));
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
|
fn choose_weighted_option<T:Clone>(&mut self, v: &[Weighted<T>])
|
||||||
-> Option<T> {
|
-> Option<T> {
|
||||||
let mut total = 0u;
|
let mut total = 0u;
|
||||||
|
@ -576,7 +445,7 @@ impl<R: Rng> RngUtil for R {
|
||||||
if total == 0u {
|
if total == 0u {
|
||||||
return None;
|
return None;
|
||||||
}
|
}
|
||||||
let chosen = self.gen_uint_range(0u, total);
|
let chosen = self.gen_integer_range(0u, total);
|
||||||
let mut so_far = 0u;
|
let mut so_far = 0u;
|
||||||
for item in v.iter() {
|
for item in v.iter() {
|
||||||
so_far += item.weight;
|
so_far += item.weight;
|
||||||
|
@ -587,10 +456,23 @@ impl<R: Rng> RngUtil for R {
|
||||||
unreachable!();
|
unreachable!();
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/// Return a vec containing copies of the items, in order, where
|
||||||
* Return a vec containing copies of the items, in order, where
|
/// the weight of the item determines how many copies there are
|
||||||
* the weight of the item determines how many copies there are
|
///
|
||||||
*/
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
/// use std::rand::Rng;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// let mut rng = rand::rng();
|
||||||
|
/// let x = [rand::Weighted {weight: 4, item: 'a'},
|
||||||
|
/// rand::Weighted {weight: 2, item: 'b'},
|
||||||
|
/// rand::Weighted {weight: 2, item: 'c'}];
|
||||||
|
/// printfln!(rng.weighted_vec(x));
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
|
fn weighted_vec<T:Clone>(&mut self, v: &[Weighted<T>]) -> ~[T] {
|
||||||
let mut r = ~[];
|
let mut r = ~[];
|
||||||
for item in v.iter() {
|
for item in v.iter() {
|
||||||
|
@ -602,24 +484,61 @@ impl<R: Rng> RngUtil for R {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Shuffle a vec
|
/// Shuffle a vec
|
||||||
fn shuffle<T:Clone>(&mut self, values: &[T]) -> ~[T] {
|
///
|
||||||
let mut m = values.to_owned();
|
/// # Example
|
||||||
self.shuffle_mut(m);
|
///
|
||||||
m
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// printfln!(rand::task_rng().shuffle(~[1,2,3]));
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
|
fn shuffle<T>(&mut self, values: ~[T]) -> ~[T] {
|
||||||
|
let mut v = values;
|
||||||
|
self.shuffle_mut(v);
|
||||||
|
v
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Shuffle a mutable vec in place
|
/// Shuffle a mutable vector in place.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// let rng = rand::task_rng();
|
||||||
|
/// let mut y = [1,2,3];
|
||||||
|
/// rng.shuffle_mut(y);
|
||||||
|
/// printfln!(y);
|
||||||
|
/// rng.shuffle_mut(y);
|
||||||
|
/// printfln!(y);
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
fn shuffle_mut<T>(&mut self, values: &mut [T]) {
|
fn shuffle_mut<T>(&mut self, values: &mut [T]) {
|
||||||
let mut i = values.len();
|
let mut i = values.len();
|
||||||
while i >= 2u {
|
while i >= 2u {
|
||||||
// invariant: elements with index >= i have been locked in place.
|
// invariant: elements with index >= i have been locked in place.
|
||||||
i -= 1u;
|
i -= 1u;
|
||||||
// lock element i in place.
|
// lock element i in place.
|
||||||
values.swap(i, self.gen_uint_range(0u, i + 1u));
|
values.swap(i, self.gen_integer_range(0u, i + 1u));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Randomly sample up to `n` elements from an iterator
|
/// Randomly sample up to `n` elements from an iterator.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
///
|
||||||
|
/// ~~~ {.rust}
|
||||||
|
/// use std::rand;
|
||||||
|
///
|
||||||
|
/// fn main() {
|
||||||
|
/// let rng = rand::task_rng();
|
||||||
|
/// let sample = rng.sample(range(1, 100), 5);
|
||||||
|
/// printfln!(sample);
|
||||||
|
/// }
|
||||||
|
/// ~~~
|
||||||
fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
|
fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
|
||||||
let mut reservoir : ~[A] = vec::with_capacity(n);
|
let mut reservoir : ~[A] = vec::with_capacity(n);
|
||||||
for (i, elem) in iter.enumerate() {
|
for (i, elem) in iter.enumerate() {
|
||||||
|
@ -628,7 +547,7 @@ impl<R: Rng> RngUtil for R {
|
||||||
loop
|
loop
|
||||||
}
|
}
|
||||||
|
|
||||||
let k = self.gen_uint_range(0, i + 1);
|
let k = self.gen_integer_range(0, i + 1);
|
||||||
if k < reservoir.len() {
|
if k < reservoir.len() {
|
||||||
reservoir[k] = elem
|
reservoir[k] = elem
|
||||||
}
|
}
|
||||||
|
@ -961,7 +880,7 @@ mod test {
|
||||||
let seed = seed();
|
let seed = seed();
|
||||||
let mut ra = IsaacRng::new_seeded(seed);
|
let mut ra = IsaacRng::new_seeded(seed);
|
||||||
let mut rb = IsaacRng::new_seeded(seed);
|
let mut rb = IsaacRng::new_seeded(seed);
|
||||||
assert_eq!(ra.gen_str(100u), rb.gen_str(100u));
|
assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -970,7 +889,7 @@ mod test {
|
||||||
let seed = [2u8, 32u8, 4u8, 32u8, 51u8];
|
let seed = [2u8, 32u8, 4u8, 32u8, 51u8];
|
||||||
let mut ra = IsaacRng::new_seeded(seed);
|
let mut ra = IsaacRng::new_seeded(seed);
|
||||||
let mut rb = IsaacRng::new_seeded(seed);
|
let mut rb = IsaacRng::new_seeded(seed);
|
||||||
assert_eq!(ra.gen_str(100u), rb.gen_str(100u));
|
assert_eq!(ra.gen_ascii_str(100u), rb.gen_ascii_str(100u));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -985,35 +904,36 @@ mod test {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_gen_int_range() {
|
fn test_gen_integer_range() {
|
||||||
let mut r = rng();
|
let mut r = rng();
|
||||||
let a = r.gen_int_range(-3, 42);
|
for _ in range(0, 1000) {
|
||||||
assert!(a >= -3 && a < 42);
|
let a = r.gen_integer_range(-3i, 42);
|
||||||
assert_eq!(r.gen_int_range(0, 1), 0);
|
assert!(a >= -3 && a < 42);
|
||||||
assert_eq!(r.gen_int_range(-12, -11), -12);
|
assert_eq!(r.gen_integer_range(0, 1), 0);
|
||||||
|
assert_eq!(r.gen_integer_range(-12, -11), -12);
|
||||||
|
}
|
||||||
|
|
||||||
|
for _ in range(0, 1000) {
|
||||||
|
let a = r.gen_integer_range(10, 42);
|
||||||
|
assert!(a >= 10 && a < 42);
|
||||||
|
assert_eq!(r.gen_integer_range(0, 1), 0);
|
||||||
|
assert_eq!(r.gen_integer_range(3_000_000u, 3_000_001), 3_000_000);
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
#[should_fail]
|
#[should_fail]
|
||||||
fn test_gen_int_from_fail() {
|
fn test_gen_integer_range_fail_int() {
|
||||||
let mut r = rng();
|
let mut r = rng();
|
||||||
r.gen_int_range(5, -2);
|
r.gen_integer_range(5i, -2);
|
||||||
}
|
|
||||||
|
|
||||||
#[test]
|
|
||||||
fn test_gen_uint_range() {
|
|
||||||
let mut r = rng();
|
|
||||||
let a = r.gen_uint_range(3u, 42u);
|
|
||||||
assert!(a >= 3u && a < 42u);
|
|
||||||
assert_eq!(r.gen_uint_range(0u, 1u), 0u);
|
|
||||||
assert_eq!(r.gen_uint_range(12u, 13u), 12u);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
#[should_fail]
|
#[should_fail]
|
||||||
fn test_gen_uint_range_fail() {
|
fn test_gen_integer_range_fail_uint() {
|
||||||
let mut r = rng();
|
let mut r = rng();
|
||||||
r.gen_uint_range(5u, 2u);
|
r.gen_integer_range(5u, 2u);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -1032,22 +952,22 @@ mod test {
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_gen_str() {
|
fn test_gen_ascii_str() {
|
||||||
let mut r = rng();
|
let mut r = rng();
|
||||||
debug!(r.gen_str(10u));
|
debug!(r.gen_ascii_str(10u));
|
||||||
debug!(r.gen_str(10u));
|
debug!(r.gen_ascii_str(10u));
|
||||||
debug!(r.gen_str(10u));
|
debug!(r.gen_ascii_str(10u));
|
||||||
assert_eq!(r.gen_str(0u).len(), 0u);
|
assert_eq!(r.gen_ascii_str(0u).len(), 0u);
|
||||||
assert_eq!(r.gen_str(10u).len(), 10u);
|
assert_eq!(r.gen_ascii_str(10u).len(), 10u);
|
||||||
assert_eq!(r.gen_str(16u).len(), 16u);
|
assert_eq!(r.gen_ascii_str(16u).len(), 16u);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_gen_bytes() {
|
fn test_gen_vec() {
|
||||||
let mut r = rng();
|
let mut r = rng();
|
||||||
assert_eq!(r.gen_bytes(0u).len(), 0u);
|
assert_eq!(r.gen_vec::<u8>(0u).len(), 0u);
|
||||||
assert_eq!(r.gen_bytes(10u).len(), 10u);
|
assert_eq!(r.gen_vec::<u8>(10u).len(), 10u);
|
||||||
assert_eq!(r.gen_bytes(16u).len(), 16u);
|
assert_eq!(r.gen_vec::<f64>(16u).len(), 16u);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -1059,9 +979,12 @@ mod test {
|
||||||
#[test]
|
#[test]
|
||||||
fn test_choose_option() {
|
fn test_choose_option() {
|
||||||
let mut r = rng();
|
let mut r = rng();
|
||||||
let x: Option<int> = r.choose_option([]);
|
let v: &[int] = &[];
|
||||||
assert!(x.is_none());
|
assert!(r.choose_option(v).is_none());
|
||||||
assert_eq!(r.choose_option([1, 1, 1]), Some(1));
|
|
||||||
|
let i = 1;
|
||||||
|
let v = [1,1,1];
|
||||||
|
assert_eq!(r.choose_option(v), Some(&i));
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
@ -1106,16 +1029,16 @@ mod test {
|
||||||
fn test_shuffle() {
|
fn test_shuffle() {
|
||||||
let mut r = rng();
|
let mut r = rng();
|
||||||
let empty: ~[int] = ~[];
|
let empty: ~[int] = ~[];
|
||||||
assert_eq!(r.shuffle([]), empty);
|
assert_eq!(r.shuffle(~[]), empty);
|
||||||
assert_eq!(r.shuffle([1, 1, 1]), ~[1, 1, 1]);
|
assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn test_task_rng() {
|
fn test_task_rng() {
|
||||||
let mut r = task_rng();
|
let mut r = task_rng();
|
||||||
r.gen::<int>();
|
r.gen::<int>();
|
||||||
assert_eq!(r.shuffle([1, 1, 1]), ~[1, 1, 1]);
|
assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
|
||||||
assert_eq!(r.gen_uint_range(0u, 1u), 0u);
|
assert_eq!(r.gen_integer_range(0u, 1u), 0u);
|
||||||
}
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
|
|
|
@ -1095,7 +1095,7 @@ mod test {
|
||||||
#[test]
|
#[test]
|
||||||
fn megapipe_stress() {
|
fn megapipe_stress() {
|
||||||
use rand;
|
use rand;
|
||||||
use rand::RngUtil;
|
use rand::Rng;
|
||||||
|
|
||||||
if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
|
if util::limit_thread_creation_due_to_osx_and_valgrind() { return; }
|
||||||
|
|
||||||
|
@ -1106,7 +1106,7 @@ mod test {
|
||||||
let total = stress_factor() + 10;
|
let total = stress_factor() + 10;
|
||||||
let mut rng = rand::rng();
|
let mut rng = rand::rng();
|
||||||
do total.times {
|
do total.times {
|
||||||
let msgs = rng.gen_uint_range(0, 10);
|
let msgs = rng.gen_integer_range(0u, 10);
|
||||||
let pipe_clone = pipe.clone();
|
let pipe_clone = pipe.clone();
|
||||||
let end_chan_clone = end_chan.clone();
|
let end_chan_clone = end_chan.clone();
|
||||||
do spawntask_random {
|
do spawntask_random {
|
||||||
|
|
|
@ -26,7 +26,7 @@ use rt::local::Local;
|
||||||
use rt::rtio::{RemoteCallback, PausibleIdleCallback};
|
use rt::rtio::{RemoteCallback, PausibleIdleCallback};
|
||||||
use borrow::{to_uint};
|
use borrow::{to_uint};
|
||||||
use cell::Cell;
|
use cell::Cell;
|
||||||
use rand::{XorShiftRng, RngUtil};
|
use rand::{XorShiftRng, Rng};
|
||||||
use iter::range;
|
use iter::range;
|
||||||
use vec::{OwnedVector};
|
use vec::{OwnedVector};
|
||||||
|
|
||||||
|
@ -391,7 +391,7 @@ impl Scheduler {
|
||||||
fn try_steals(&mut self) -> Option<~Task> {
|
fn try_steals(&mut self) -> Option<~Task> {
|
||||||
let work_queues = &mut self.work_queues;
|
let work_queues = &mut self.work_queues;
|
||||||
let len = work_queues.len();
|
let len = work_queues.len();
|
||||||
let start_index = self.rng.gen_uint_range(0, len);
|
let start_index = self.rng.gen_integer_range(0, len);
|
||||||
for index in range(0, len).map(|i| (i + start_index) % len) {
|
for index in range(0, len).map(|i| (i + start_index) % len) {
|
||||||
match work_queues[index].steal() {
|
match work_queues[index].steal() {
|
||||||
Some(task) => {
|
Some(task) => {
|
||||||
|
|
|
@ -15,7 +15,7 @@ extern mod extra;
|
||||||
use extra::time::precise_time_s;
|
use extra::time::precise_time_s;
|
||||||
use std::io;
|
use std::io;
|
||||||
use std::os;
|
use std::os;
|
||||||
use std::rand::RngUtil;
|
use std::rand::Rng;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
use std::str;
|
use std::str;
|
||||||
use std::util;
|
use std::util;
|
||||||
|
@ -85,7 +85,7 @@ fn vec_plus() {
|
||||||
let mut v = ~[];
|
let mut v = ~[];
|
||||||
let mut i = 0;
|
let mut i = 0;
|
||||||
while i < 1500 {
|
while i < 1500 {
|
||||||
let rv = vec::from_elem(r.gen_uint_range(0, i + 1), i);
|
let rv = vec::from_elem(r.gen_integer_range(0u, i + 1), i);
|
||||||
if r.gen() {
|
if r.gen() {
|
||||||
v.push_all_move(rv);
|
v.push_all_move(rv);
|
||||||
} else {
|
} else {
|
||||||
|
@ -101,7 +101,7 @@ fn vec_append() {
|
||||||
let mut v = ~[];
|
let mut v = ~[];
|
||||||
let mut i = 0;
|
let mut i = 0;
|
||||||
while i < 1500 {
|
while i < 1500 {
|
||||||
let rv = vec::from_elem(r.gen_uint_range(0, i + 1), i);
|
let rv = vec::from_elem(r.gen_integer_range(0u, i + 1), i);
|
||||||
if r.gen() {
|
if r.gen() {
|
||||||
v = vec::append(v, rv);
|
v = vec::append(v, rv);
|
||||||
}
|
}
|
||||||
|
@ -117,7 +117,7 @@ fn vec_push_all() {
|
||||||
|
|
||||||
let mut v = ~[];
|
let mut v = ~[];
|
||||||
for i in range(0u, 1500) {
|
for i in range(0u, 1500) {
|
||||||
let mut rv = vec::from_elem(r.gen_uint_range(0, i + 1), i);
|
let mut rv = vec::from_elem(r.gen_integer_range(0u, i + 1), i);
|
||||||
if r.gen() {
|
if r.gen() {
|
||||||
v.push_all(rv);
|
v.push_all(rv);
|
||||||
}
|
}
|
||||||
|
|
|
@ -1,7 +1,7 @@
|
||||||
// Perlin noise benchmark from https://gist.github.com/1170424
|
// Perlin noise benchmark from https://gist.github.com/1170424
|
||||||
|
|
||||||
use std::float;
|
use std::float;
|
||||||
use std::rand::{Rng, RngUtil};
|
use std::rand::Rng;
|
||||||
use std::rand;
|
use std::rand;
|
||||||
|
|
||||||
struct Vec2 {
|
struct Vec2 {
|
||||||
|
|
Loading…
Reference in New Issue