How can I (should i) include rand::Rng in my own struct? - rust

Question

I'm writing a graphical simulation to analyze physics interactions at the subatomic level and doing so by creating my own structures (struct Simiulation, struct Particle,...). For initial testing and development purposes I'm using rand::thread_rng().gen_rang(). In order to use this simulation, I have to add use rand::Rng; at the top of the file. As a new Rust user (1 week), I'm unsure if this can be included automatically, without having to type it, in the event I share the simulation with a colleague for collaborative purposes.
I googled nested namespaces which presented C++ / JS options but not Rust. I checked StackOverflow as well, but didn't find anything. I haven't reached the Cargo section in the Book as of yet. My terminology man be incorrect, so let me know if it's called something else in Rust.
Partial Sample Code
use rand::Rng; // <-- Nest this?
// - global -
const NUM_PARTICLES: usize = 5;
const WINDOW_WIDTH: f64 = 500.0; // TODO: Determine Window Width
const WINDOW_HEIGHT: f64 = 500.0; // TODO: Determine Window Height
const PARTICLE_RADIUS: f64 = 2.0; // TODO: Generate max probability distributon
// cross-sectional area to be used (per particle)
fn main() {
let mut starting_image = generate_starting_image();
println!("{:#?}", starting_image);
}
// Each particle has a position with respect to
// the origin and is denoted by (x, y)
// where x is the projection of the position along
// the x-axis and y is the projection of the position along
// the y-axis.
//
// Each particle has a veloctiy denoted by (Vx, Vy)
// where Vx is the velocity component along the x-axis and
// Vy is the velocity component along the y-axis.
#[derive(Debug, Copy, Clone)]
struct Mass {
mass: f64,
}
impl Mass {
// generate random mass for the particle (in kgs)
fn random() -> Self {
Self {
mass: rand::thread_rng().gen_range(1.00..=6.00),
}
}
}
#[derive(Debug, Copy, Clone)]
struct Position {
x: f64,
y: f64,
}
impl Position {
// generate random starting position (x, y) for a particle
fn random() -> Self {
Self {
x: rand::thread_rng().gen_range(1.0..=(WINDOW_WIDTH - 1.0)),
y: rand::thread_rng().gen_range(1.0..=(WINDOW_HEIGHT - 1.0)),
}
}
}
#[derive(Debug, Copy, Clone)]
struct Velocity {
vx: f64,
vy: f64,
}
impl Velocity {
// generate random starting velocity (vx, vy) for a particle
fn random() -> Self {
Self {
vx: rand::thread_rng().gen_range(5.0..20.0),
vy: rand::thread_rng().gen_range(5.0..20.0),
}
}
}
#[derive(Debug, Copy, Clone)]
struct Particle {
position: Position,
velocity: Velocity,
mass: Mass, // mass in kilograms
}
impl Particle {
fn random() -> Self {
Self {
position: Position::random(),
velocity: Velocity::random(),
mass: Mass::random(),
}
}
}
// An image is a snapshot of all the attribute values for each
// particle at some given time interval dt.
#[derive(Debug, Copy, Clone)]
struct Image {
particles: [Particle; NUM_PARTICLES],
}
// Calculate the distance between two points. Necessary to
// determine if a collision is taken place
fn distance (particle_1: &Particle, particle_2: &Particle) -> f64 {
let base_1: f64 = particle_1.position.x - particle_2.position.x;
let base_2: f64 = particle_1.position.y - particle_2.position.y;
let base: f64 = f64::powf(base_1, 2.0) + f64::powf(base_2, 2.0);
f64::powf(base, 0.5)
}
fn generate_starting_image() -> Image {
let mut starting_image = Image {
particles: [Particle::random(); NUM_PARTICLES]
};
let iter = starting_image.particles.iter();
let mut num_created_particles: usize = 0;
// Loop over the starting_image array to populate the
// array with starting particle values
loop {
// stop the loop when the number of particles has
// been generated
if num_created_particles == NUM_PARTICLES { break; }
// loop over the populated values and check to
// make sure the distance between the newly generated
// particle does not occupy the same position as
// a previously generated particle
// Particle to test
let mut current_particle = Particle::random();
// indices of checked particles
let mut checked_particles: usize = 0;
while checked_particles < num_created_particles {
if distance(&current_particle, &starting_image.particles[checked_particles]) <= 4.0 {
current_particle = Particle::random();
checked_particles = 0;
}
// Newly generated particle is further than the minimum
// needed to be placed. increment to next particle to
// be checked.
checked_particles = checked_particles + 1;
}
// Newly generated particle has been checked for proximity
// against all previously generated particles. Insert
// into the particle array and increment to
// generate the next particle
println!("num_created_particles = {num_created_particles}");
starting_image.particles[num_created_particles] = current_particle;
num_created_particles = num_created_particles + 1;
checked_particles = 0;
}
// The starting values for each particle has been generated.
// Return array to begin the simulation
starting_image
}