Trait tiamat::Random

pub trait Random {
    fn random<G: RandomGen>(rng: &mut G) -> Self;
}

A type that can be (pseudo-)randomly generated using a RandomGen.

Required Methods

fn random<G: RandomGen>(rng: &mut G) -> Self

Randomly generates a value.

In general, the generates values will be uniformly distributed in some way. See the instance documentations for more details.

In most cases, you might want to use RandomGen's wrapper method gen instead of writing out Random::random or Type::random.

Example

use tiamat::Random;

let mut rng = get_rng();

for i in 1..6 {
    let result = if bool::random(&mut rng) {
        "heads"
    } else {
        "tails"
    };
    println!("Coin flip #{}: {}!", i, result);
}

Implementations on Foreign Types

impl Random for u32

fn random<G: RandomGen>(rng: &mut G) -> u32

Generates values that are uniformly distributed among all possible values.

impl Random for u64

fn random<G: RandomGen>(rng: &mut G) -> u64

Generates values that are uniformly distributed among all possible values.

impl Random for u128

fn random<G: RandomGen>(rng: &mut G) -> u128

Generates values that are uniformly distributed among all possible values.

impl Random for u8

fn random<G: RandomGen>(rng: &mut G) -> u8

Generates values that are uniformly distributed among all possible values.

impl Random for u16

fn random<G: RandomGen>(rng: &mut G) -> u16

Generates values that are uniformly distributed among all possible values.

impl Random for i8

fn random<G: RandomGen>(rng: &mut G) -> i8

Generates values that are uniformly distributed among all possible values.

impl Random for i16

fn random<G: RandomGen>(rng: &mut G) -> i16

Generates values that are uniformly distributed among all possible values.

impl Random for i32

fn random<G: RandomGen>(rng: &mut G) -> i32

Generates values that are uniformly distributed among all possible values.

impl Random for i64

fn random<G: RandomGen>(rng: &mut G) -> i64

Generates values that are uniformly distributed among all possible values.

impl Random for i128

fn random<G: RandomGen>(rng: &mut G) -> i128

Generates values that are uniformly distributed among all possible values.

impl Random for usize

fn random<G: RandomGen>(rng: &mut G) -> usize

Generates values that are uniformly distributed among all possible values.

impl Random for isize

fn random<G: RandomGen>(rng: &mut G) -> isize

Generates values that are uniformly distributed among all possible values.

impl Random for f32

fn random<G: RandomGen>(rng: &mut G) -> f32

Generates uniformly distributed values in the closed interval [0.0, 1.0].

Here, uniformly distributed that the generated values are as if a random real number in [0.0, 1.0] was generated and then rounded to the nearest floating point number.

impl Random for f64

fn random<G: RandomGen>(rng: &mut G) -> f64

Generates uniformly distributed values in the closed interval [0.0, 1.0].

Here, uniformly distributed that the generated values are as if a random real number in [0.0, 1.0] was generated and then rounded to the nearest floating point number.

impl Random for bool

fn random<G: RandomGen>(rng: &mut G) -> bool

Returns true and false with equal probability.

impl<R: Random> Random for Option<R>

fn random<G: RandomGen>(rng: &mut G) -> Option<R>

Returns Some(rng.gen()) and None with equal probability.

The Some and None variants have equal probability; if a Some is generated, then the value inside is generated with its Random instance.

impl Random for char

fn random<G: RandomGen>(rng: &mut G) -> char

Returns a char uniformly distributed among legal values, i.e. among Unicode scalar values.

impl Random for ()

fn random<G: RandomGen>(_: &mut G)

Returns ().

impl<A: Random> Random for (A,)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

impl<A: Random, B: Random> Random for (A, B)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

impl<A: Random, B: Random, C: Random> Random for (A, B, C)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

impl<A: Random, B: Random, C: Random, D: Random> Random for (A, B, C, D)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

impl<A: Random, B: Random, C: Random, D: Random, E: Random> Random for (A, B, C, D, E)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random> Random for (A, B, C, D, E, F)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random> Random for (A, B, C, D, E, F, G)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

impl<A: Random, B: Random, C: Random, D: Random, E: Random, F: Random, G: Random, H: Random> Random for (A, B, C, D, E, F, G, H)

fn random<Gen: RandomGen>(rng: &mut Gen) -> Self

Returns a tuple where each value was generated according to its own implementation of Random.

Implementors

• impl Random for Pcg