Struct elevate_lib::floor::Floor

pub struct Floor {
    pub capacity: usize,
    pub dest_prob: f64,
    /* private fields */
}

Floor struct

A Floor is aggregated by buildings. People travel between them using elevators. The floor struct generally should not be directly instantiated; instead it should be managed in aggregate via the Building type.

Fields

capacity: usize

dest_prob: f64

Implementations

impl Floor

Floor type implementation

The following functions are used by Buildings and Floors implementations.

pub fn new(capacity: usize) -> Floor

Initialize a new Floor with a zero destination probability and an empty vector of Persons.

Example

let capacity: usize = 100_usize;
let my_floor: Floor = Floor::new(capacity);

pub fn get_free_capacity(&self) -> usize

Calculate the free capacity for the floor

pub fn get_p_out(&self) -> f64

Calculate the probability that a person on the floor leaves during the next time step, and return the result as an f64.

pub fn gen_people_leaving(&mut self, rng: &mut impl Rng)

Randomly generate whether anyone on the floor is leaving using each Person’s gen_is_leaving function.

pub fn flush_people_entering_elevator( &mut self, free_elevator_capacity: usize ) -> Vec<Person>

Remove people from a floor who are currently waiting/not on their desired floor and return as a Vec<Person>. This is used when the elevator is on this floor and there is an exchange of people between the elevator and the floor. The people removed from the floor are limited to the free capacity of the elevator they are entering, which is given as a usize function parameter.

pub fn flush_people_leaving_floor(&mut self) -> Vec<Person>

Remove people entirely who are leaving the building. This is used exclusively on the first floor.

Trait Implementations

impl Clone for Floor

fn clone(&self) -> Floor

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Extend<Person> for Floor

fn extend<T: IntoIterator<Item = Person>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl People for Floor

fn gen_num_tips(&self, rng: &mut impl Rng) -> usize

Generates the number of people among the collection of people who will tip.

fn get_dest_floors(&self) -> Vec<usize>

Determines the destination floors for all people on the floor and returns it as a vector.

fn get_num_people(&self) -> usize

Determines the total number of people on the floor and returns it as a usize.

fn get_num_people_waiting(&self) -> usize

Determines the number of people waiting on the floor, that is, not at their desired floor.

fn get_num_people_going_to_floor(&self, floor_to: usize) -> usize

Determines the number of people going to a particular floor

fn get_aggregate_wait_time(&self) -> usize

Reads the wait times from people waiting on the floor/not at their desired floor and aggregates the total into a usize.

fn are_people_going_to_floor(&self, floor_index: usize) -> bool

Determines whether anyone on the floor are going to a given floor, and returns a bool which is true if so, and false if not.

fn are_people_waiting(&self) -> bool

Determines whether anyone on the floor is waiting/not at their desired floor, and returns a bool which is true if so, and false if not.

fn increment_wait_times(&mut self)

Increments the wait times (by 1_usize) among all people waiting on the floor/not at their desired floor.

fn reset_wait_times(&mut self)

Resets the wait times (to 0_usize) among all people on the floor who have a nonzero wait time and are on their desired floor.