Struct RNG

pub struct RNG { /* private fields */ }

RNG is a random number generator.

Implementations

impl RNG

pub fn new() -> Self

new is a constructor.

pub fn with_seed(self, seed: u64) -> Self

with_seed is a constructor with seed.

pub fn i32_f32(&self) -> ((i32, f32), Self)

i32_f32 generates a tuple of i32 and f32.

pub fn f32_i32(&self) -> ((f32, i32), Self)

f32_i32 generates a tuple of f32 and i32.

pub fn f32_3(&self) -> ((f32, f32, f32), Self)

f32_3 generates a tuple of f32, f32 and f32.

pub fn i32s(&self, count: u32) -> (Vec<i32>, Self)

i32s generates a vector of i32 with pre-allocated capacity.

This method automatically selects the most efficient implementation based on the size:

• For small sizes (< 50,000), it uses a direct StdRng implementation
• For large sizes (>= 50,000), it uses parallel processing

pub fn i32s_direct(&self, count: u32) -> (Vec<i32>, Self)

i32s_direct generates a vector of i32 using direct StdRng access.

pub fn i32s_parallel(&self, count: u32) -> (Vec<i32>, Self)

i32s_parallel generates a vector of i32 using parallel processing.

pub fn unit<A>(a: A) -> Box<dyn FnMut(RNG) -> (A, RNG)>

where A: Clone + 'static,

unit generates a function that returns a tuple of A and RNG.

pub fn sequence<A, F>(fs: Vec<F>) -> Box<dyn FnMut(RNG) -> (Vec<A>, RNG)>

where A: Clone + 'static, F: FnMut(RNG) -> (A, RNG) + 'static,

sequence generates a function that returns a tuple of Vec<A> and RNG, pre-allocating capacity based on the number of functions.

pub fn int_value() -> Box<dyn FnMut(RNG) -> (i32, RNG)>

int_value generates a function that returns a tuple of i32 and RNG.

pub fn double_value() -> Box<dyn FnMut(RNG) -> (f32, RNG)>

double_value generates a function that returns a tuple of f32 and RNG.

pub fn map<A, B, F1, F2>(s: F1, f: F2) -> Box<dyn FnMut(RNG) -> (B, RNG)>

where F1: FnMut(RNG) -> (A, RNG) + 'static, F2: FnMut(A) -> B + 'static,

map generates a function that returns a tuple of B and RNG.

pub fn map2<F1, F2, F3, A, B, C>( ra: F1, rb: F2, f: F3, ) -> Box<dyn FnMut(RNG) -> (C, RNG)>

where F1: FnMut(RNG) -> (A, RNG) + 'static, F2: FnMut(RNG) -> (B, RNG) + 'static, F3: FnMut(A, B) -> C + 'static,

map2 generates a function that returns a tuple of C and RNG.

pub fn both<F1, F2, A, B>( ra: F1, rb: F2, ) -> Box<dyn FnMut(RNG) -> ((A, B), RNG)>

where F1: FnMut(RNG) -> (A, RNG) + 'static, F2: FnMut(RNG) -> (B, RNG) + 'static,

both generates a function that returns a tuple of (A, B) and RNG.

pub fn rand_int_double() -> Box<dyn FnMut(RNG) -> ((i32, f32), RNG)>

rand_int_double generates a function that returns a tuple of (i32, f32) and RNG.

pub fn rand_double_int() -> Box<dyn FnMut(RNG) -> ((f32, i32), RNG)>

rand_double_int generates a function that returns a tuple of (f32, i32) and RNG.

pub fn flat_map<A, B, F, GF, BF>(f: F, g: GF) -> Box<dyn FnMut(RNG) -> (B, RNG)>

where F: FnMut(RNG) -> (A, RNG) + 'static, BF: FnMut(RNG) -> (B, RNG) + 'static, GF: FnMut(A) -> BF + 'static,

flat_map generates a function that returns a tuple of B and RNG.

Trait Implementations

impl Clone for RNG

fn clone(&self) -> RNG

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RNG

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for RNG

fn default() -> Self

Returns the “default value” for a type.

impl NextRandValue for RNG

fn next_i64(&self) -> (i64, Self)

next_i64 generates an i64 and an updated instance of Self.

fn next_i32(&self) -> (i32, Self)

next_i32 generates an i32 and an updated instance of Self.

fn next_i16(&self) -> (i16, Self)

next_i16 generates an i16 and an updated instance of Self.

fn next_i8(&self) -> (i8, Self)

next_i8 generates an i8 and an updated instance of Self.

fn next_u64(&self) -> (u64, Self)

next_u64 generates a u64 and an updated instance of Self.

fn next_u32(&self) -> (u32, Self)

next_u32 generates a u32 and an updated instance of Self.

fn next_u16(&self) -> (u16, Self)

next_u16 generates a u16 and an updated instance of Self.

fn next_u8(&self) -> (u8, Self)

next_u8 generates a u8 and an updated instance of Self.

fn next_f64(&self) -> (f64, Self)

Generates an f64 in the range [0.0, 1.0) and an updated instance of Self.

fn next_f32(&self) -> (f32, Self)

Generates an f32 in the range [0.0, 1.0) and an updated instance of Self.

fn next_bool(&self) -> (bool, Self)

next_bool generates a bool and an updated instance of Self.

impl PartialEq for RNG

fn eq(&self, other: &RNG) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RNG