# Generate Random Values

## Generate random numbers

Generates random numbers with help of random-number generator `rand::Rng` obtained via `rand::thread_rng`. Each thread has an initialized generator. Integers are uniformly distributed over the range of the type, and floating point numbers are uniformly distributed from 0 up to but not including 1.

``````use rand::Rng;

fn main() {

let n1: u8 = rng.gen();
let n2: u16 = rng.gen();
println!("Random u8: {}", n1);
println!("Random u16: {}", n2);
println!("Random u32: {}", rng.gen::<u32>());
println!("Random i32: {}", rng.gen::<i32>());
println!("Random float: {}", rng.gen::<f64>());
}
``````

## Generate random numbers within a range

Generates a random value within half-open `[0, 10)` range (not including `10`) with `Rng::gen_range`.

``````use rand::Rng;

fn main() {
println!("Integer: {}", rng.gen_range(0..10));
println!("Float: {}", rng.gen_range(0.0..10.0));
}
``````

`Uniform` can obtain values with uniform distribution. This has the same effect, but may be faster when repeatedly generating numbers in the same range.

``````
use rand::distributions::{Distribution, Uniform};

fn main() {
let die = Uniform::from(1..7);

loop {
let throw = die.sample(&mut rng);
println!("Roll the die: {}", throw);
if throw == 6 {
break;
}
}
}
``````

## Generate random numbers with given distribution

By default, random numbers in the `rand` crate have uniform distribution. The `rand_distr` crate provides other kinds of distributions. To use them, you instantiate a distribution, then sample from that distribution using `Distribution::sample` with help of a random-number generator `rand::Rng`.

The distributions available are documented here. An example using the `Normal` distribution is shown below.

``````use rand_distr::{Distribution, Normal, NormalError};

fn main() -> Result<(), NormalError> {
let normal = Normal::new(2.0, 3.0)?;
let v = normal.sample(&mut rng);
println!("{} is from a N(2, 9) distribution", v);
Ok(())
}
``````

## Generate random values of a custom type

Randomly generates a tuple `(i32, bool, f64)` and variable of user defined type `Point`. Implements the `Distribution` trait on type Point for `Standard` in order to allow random generation.

``````use rand::Rng;
use rand::distributions::{Distribution, Standard};

#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}

impl Distribution<Point> for Standard {
fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Point {
let (rand_x, rand_y) = rng.gen();
Point {
x: rand_x,
y: rand_y,
}
}
}

fn main() {
let rand_tuple = rng.gen::<(i32, bool, f64)>();
let rand_point: Point = rng.gen();
println!("Random tuple: {:?}", rand_tuple);
println!("Random Point: {:?}", rand_point);
}
``````

## Create random passwords from a set of alphanumeric characters

Randomly generates a string of given length ASCII characters in the range `A-Z, a-z, 0-9`, with `Alphanumeric` sample.

``````use rand::{thread_rng, Rng};
use rand::distributions::Alphanumeric;

fn main() {
.sample_iter(&Alphanumeric)
.take(30)
.map(char::from)
.collect();

println!("{}", rand_string);
}
``````

## Create random passwords from a set of user-defined characters

Randomly generates a string of given length ASCII characters with custom user-defined bytestring, with `gen_range`.

``````fn main() {
use rand::Rng;
const CHARSET: &[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
abcdefghijklmnopqrstuvwxyz\
0123456789)(*&^%\$#@!~";