The Problem
As part of my doomed efforts to learn Rust, I decided to get to grips with how the language handles classes and objects. But, instead of taking on some well-known exercise, I thought it would be more fun to try to answer a question which has been nibbling at the back of my mind since I was eleven or twelve...
What is this question? The Wikipedia page for the song "Flowers in the Window" by Scottish rock band Travis describes the video like this:
The video features the band walking around a small town where all the residents are pregnant women. The band enter a clinic where women are staying and begin to perform the song. A chained-up man in distress appears at the end of the video.
The question which has fascinated me for two decades is: Would such a community actually be feasible, from a mathematical point of view? And, if so, what is the mathematical limit on its size? My answer to this involves simulating the scenario with
The Code
main.rs
/// This is the entry point to the program.
// Declare local modules.
mod female;
mod gynaeceum;
mod utils;
/// This is where the magic happens.
fn main() {
let mut gynaeceum = gynaeceum::Gynaeceum::new();
gynaeceum.run_sim();
}
female.rs
/// This code defines the Female class.
// Local imports.
use crate::utils;
// Local constants.
const PROB_FALLING_PREGNANT_PER_COPULATION: f64 = 0.05;
const PROB_FEMALE_OFFSPRING: f64 = 0.5;
const LENGTH_OF_PREGNANCY_IN_DAYS: i32 = 270;
const LENGTH_OF_YEAR_IN_DAYS: i32 = 365;
const MIN_FERTILE_AGE_IN_DAYS: i32 = 15*LENGTH_OF_YEAR_IN_DAYS;
const MAX_FERTILE_AGE_IN_DAYS: i32 = 45*LENGTH_OF_YEAR_IN_DAYS;
// Helper enum.
#[derive(PartialEq)]
pub enum FemaleStatusCode {
Normal,
GivenBirth,
Infertile
}
/// Structure.
pub struct Female {
id: i32,
age_in_days: i32,
is_pregnant: bool,
days_of_pregnancy: i32
}
/// Implementation.
impl Female {
pub fn new(id: i32) -> Female {
let result =
Female {
id: id,
age_in_days: 0,
is_pregnant: false,
days_of_pregnancy: 0
};
return result;
}
pub fn set_age(&mut self, new_age_in_days: i32) {
self.age_in_days = new_age_in_days;
}
pub fn can_copulate(&mut self) -> bool {
if
self.is_pregnant ||
self.age_in_days < MIN_FERTILE_AGE_IN_DAYS ||
self.age_in_days > MAX_FERTILE_AGE_IN_DAYS
{
return false;
}
return true;
}
pub fn copulate(&mut self) -> bool {
if self.is_pregnant {
return false;
}
if utils::happens(PROB_FALLING_PREGNANT_PER_COPULATION) {
self.is_pregnant = true;
return true;
}
return false;
}
pub fn give_birth(&mut self) -> bool {
self.is_pregnant = false;
self.days_of_pregnancy = 0;
if utils::happens(PROB_FEMALE_OFFSPRING) {
return true; // I.e. has given birth to a girl.
}
return false; // I.e. has given birth to a boy.
}
pub fn tick(&mut self) -> FemaleStatusCode {
self.age_in_days += 1;
if self.is_pregnant {
if self.days_of_pregnancy > LENGTH_OF_PREGNANCY_IN_DAYS {
return FemaleStatusCode::GivenBirth;
} else {
self.days_of_pregnancy += 1;
}
} else if self.age_in_days > MAX_FERTILE_AGE_IN_DAYS {
return FemaleStatusCode::Infertile;
}
return FemaleStatusCode::Normal;
}
pub fn get_id(&mut self) -> i32 {
return self.id;
}
}
gynaeceum.rs
/// This code defines a class which models "the Gynaeceum".
// Standard imports.
use std::collections::HashMap;
// Non-standard imports.
use rand::seq::SliceRandom;
// Local imports.
use crate::female;
// Local constants.
const SIM_LENGTH_IN_DAYS: i32 = 365*1000;
const SIM_INITIAL_FEMALE_COUNT: i32 = 4;
const FOUNDING_FEMALE_AGE_IN_DAYS: i32 = 365*20;
/// Structure.
pub struct Gynaeceum {
duration_in_days: i32,
next_ticket: i32,
females: HashMap<i32, female::Female>
}
/// Implementation.
impl Gynaeceum {
pub fn new() -> Gynaeceum {
let result =
Gynaeceum {
duration_in_days: 0,
next_ticket: 1,
females: HashMap::new()
};
return result;
}
fn get_ticket(&mut self) -> i32 {
let result = self.next_ticket;
self.next_ticket += 1;
return result;
}
fn add_female(&mut self) {
let mut new_female = female::Female::new(self.get_ticket());
self.females.insert(new_female.get_id(), new_female);
}
fn process_retirees(&mut self, retiree_ids: Vec<i32>) {
for id in retiree_ids {
self.females.remove(&id);
}
}
fn service(&mut self, available: Vec<i32>) -> bool {
if available.len() == 0 {
return false;
}
let selected_id = available.choose(&mut rand::thread_rng());
let selected = self.females.get_mut(selected_id.unwrap()).unwrap();
selected.copulate();
return true;
}
fn tick(&mut self) {
let mut available = Vec::new();
let mut retiree_ids = Vec::new();
let mut birth_count = 0;
for (id, female) in self.females.iter_mut() {
let status_code = female.tick();
if status_code == female::FemaleStatusCode::GivenBirth {
if female.give_birth() {
birth_count += 1;
}
} else if status_code == female::FemaleStatusCode::Infertile {
retiree_ids.push(*id);
} else if status_code == female::FemaleStatusCode::Normal {
if female.can_copulate() {
available.push(*id);
}
}
}
for _ in 0..birth_count {
self.add_female();
}
self.process_retirees(retiree_ids);
self.service(available);
self.duration_in_days += 1;
}
pub fn run_sim(&mut self) {
for _ in 0..SIM_INITIAL_FEMALE_COUNT {
self.add_female();
}
for (_, female) in self.females.iter_mut() {
female.set_age(FOUNDING_FEMALE_AGE_IN_DAYS);
}
while self.duration_in_days <= SIM_LENGTH_IN_DAYS {
self.tick();
}
println!("Female count: {}", self.females.len());
}
}
utils.rs
/// This code defines some utility functions.
// Standard import.
use rand::Rng;
/// Decide randomly whether an event with a given probability happens.
pub fn happens(event_probability: f64) -> bool {
if rand::thread_rng().gen_range(0.0..1.0) < event_probability {
return true;
}
return false;
}
The Results
- After sufficiently many days, the population seems to level off at around 400.
- If one tinkers with the constant
PROB_FALLING_PREGNANT_PER_COPULATION, any increase or decrease will result in a directly proportional change in the population limit. - Tinkering with the other constants did not result in any appreciable change in the population limit.
