P3-M 4/25 Simulations

Creating simulations using pandas and python libraries

  • toc:true- badges: false
  • comments: true

Objectives

  1. Understand how computers can be used to represent real-world phenomena or outcomes
  2. Compare simulations with real-world contexts.
  3. Implement code to mimic real world situations, problems, or phenomena.

What are simulations by College Board definition?

  • Simulations are computer programs_ that mimic more complex objects or phenomena from the real world
    • Purposes include drawing inferences without the cost or risk__ of the real world
  • Simulations use varying sets of values to reflect the current___ state of a real phenomenon
  • Often, when developing a simulation, it is necessary to remove specific variables__ or simplify aspects
    • Simulations can often contain biases__ based on which details or real-world elements were included/excluded
  • Simulations allow the formulation of _hypotheses__ under consideration
  • Variability and uncertainty___ of the world is considered using random number generators
  • Examples: rolling dice, spinners, molecular models, analyze chemicals/reactions...

Analyzing an Example: Air-Traffic Simulator

  • Say we want to find out what the optimal number of aircrafts that can be in the air in one area is.
  • A simulation allows us to explore this question without real world contraints of money, time, safety
    • Unfortunately we can't just fly 67 planes all at once and see what happens
  • Since the simulation won't be able to take all variables into control, it may have a bias towards one answer
  • Will not always have the same result

Functions we often need (python)

import random #a module that defines a series of functions for generating or manipulating random integers
random.choice() #returns a randomly selected element from the specified sequence
random.choice(mylist) # returns random value from list
random.randint(0,10) #randomly selects an integer from given range; range in this case is from 0 to 10
random.random() #will generate a random float between 0.0 to 1.

Functions we often need (js)

// Math.random(); returns a random number
// Math.floor(Math.random() * 10); // Returns a random integer from 0 to 9:

College Board Question 1

Question: The following code simulates the feeding of 4 fish in an aquarium while the owner is on a 5-day trip:

numFish ← 4

foodPerDay ← 20

foodLeft ← 160

daysStarving ← 0

    REPEAT 5 TIMES {

    foodConsumed ← numFish * foodPerDay

    foodLeft ← foodLeft - foodConsumed

    IF (foodLeft < 0) {

    daysStarving ← daysStarving + 1

    }

}

  • This simulation simplifies a real-world scenario into something that can be modeled in code and executed on a computer.
  • Summarize how the code works:

4 fish, find out how much food is consumed and how much food is remaining for five days. If there is no more food left, you can find out how many days the fish have had no food.

Examples

Card Flip

import random

cards = ["Ace", "2", "3", "4", "5", "6", "7", "8", "9", "10", "Jack", "Queen", "King"] 
suits = ["Diamonds", "Hearts", "Spades", "Clubs"]

print(random.choice(cards) + " of " + random.choice(suits))
3 of Diamonds

Coin Flip

import random

def coinflip():         #def function 
    randomflip = random.randint(0, 0) #picks either 0 or 1 randomly 
    if randomflip == 0: #assigning 0 to be heads--> if 0 is chosen then it will print, "Heads"
        print("Heads")
    else:
        if randomflip == 1: #assigning 1 to be tails--> if 1 is chosen then it will print, "Tails"
            print("Tails")

#Tossing the coin 5 times:
t1 = coinflip()
t2 = coinflip()
t3 = coinflip()
t4 = coinflip()
t5 = coinflip()
Heads
Heads
Heads
Heads
Heads

Your turn: Change the code to make it simulate the flipping of a weighted coin.

Adding images (in Python)

  • Add a heads and tails images into your images directory with the correct names and run the code below
import random

# importing Image class from PIL package
from PIL import Image
 
# creating a object
im = Image.open(r"images/HeadsOn.png")
image = Image.open(r"images/TailsOn.jpg")

i=random.randint(0,1)

if i == 1:
    print("heads")
    display(im)

else:
    print("tails")
    display(image)
tails

In order to display an image in python, we can use the PIL package we previously learned about.

Spin the Wheel

import random

print("Spin the wheel!")
print("----------------------------------")

n = 300
blue = 0
red = 0
 
for i in range(n):
    spin = random.randint(1,2)
    if spin == 1: # head
        blue = blue + 1
    else:         # tail
        red = red + 1
 
print('Number of blue:', blue)
print('Number of red:', red)
Spin the wheel!
----------------------------------
Number of blue: 139
Number of red: 161

Your turn: Add a visual to the simulation!

Population Growth and Plots

Here we initialize the total population to be 50, then set the growth factor as 1.00005 (.005 percent change). It will print the population every 56th day until it reaches one million. It multiplies the current population by the growth factor in each iteration, and increments the day count. When the day count reaches 56, it prints the current population and resets the day count to 0.

Note! This simulation assumes that the growth factor remains constant as time progresses, which may not be a realistic assumption in real-world scenarios.

import random

totalPopulation = 50 
growthFactor = 1.00005
dayCount = 0 #Every 2 months the population is reported

while totalPopulation < 1000000:
    totalPopulation *= growthFactor
    #Every 56th day, population is reported
    dayCount += 1
    if dayCount == 56: 
        dayCount = 0
        print(totalPopulation)
import matplotlib.pyplot as plt

# Define the initial population and growth rate
population = 100
growth_rate = 0.05

# Define the number of years to simulate
num_years = 50

# Create lists to store the population and year values
populations = [population]
years = [0]

# Simulate population growth for the specified number of years
for year in range(1, num_years+1):
    # Calculate the new population size
    new_population = population + (growth_rate * population)
    # Update the population and year lists
    populations.append(new_population)
    years.append(year)
    # Set the new population as the current population for the next iteration
    population = new_population
    
# Plot the population growth over time
plt.plot(years, populations)
plt.xlabel('Year')
plt.ylabel('Population')
plt.title('Population Growth Simulation')
plt.show()

If we create quantative data, we can plot it using the Matplotlib library.

Example on how simplification can cause bias

import random

beak =  ["small-beak", "long-beak", "medium-beak"],
wing = ["small-wings", "large-wings", "medium-wings"],
height = ["short", "tall","medium"]


naturaldisaster = ["flood", "drought", "fire", "hurricane", "dustbowl"]


print("When a" , random.choice(naturaldisaster) , "hit",  random.choice(height), "birds died") 
When a hurricane hit medium birds died

How does this simulation have bias?

A random trait of birds is selected and a random natural disaster is selected, its completely random, doesn't take into account other variables like how long it occurs, etc.

JS examples

Hacks

  • Answer all questions and prompts in the notes (0.2)
  • Create a simulation
    1. Create a simulation that uses iteration and some form of data collection (list, dictionary...) (0.4)
      • try creating quantative data and using the Matplotlib library to display said data
      • Comment and describe function of each parts
      • How does your simulation help solve/mimic a real world problem?
      • Is there any bias in your simulation? Meaning, are there any discrepancies between your program and the real event?
  • Answer these simulation questions (0.3)
  • Bonus: take a real world event and make a pseudocode representation or pseudocode on a flowchart of how you would make a simulation for it (up to +0.1 bonus)

Simulation

In a real-world scenario, you might need to flip a coin a large number of times if you are making a decision with high stakes or if you need to ensure that the outcome is truly random. For example, a casino might need to flip a coin many times to ensure that the odds of winning are fair and that no one is cheating the system. With this program, you wouldn't need to worry about cheating.

One source of potential bias is the fact that this simulation assumes that the coin is perfectly symmetrical and that the chance of getting heads or tails is exactly 50%. In reality, the chance of getting heads or tails might be slightly higher or lower depending on the physical properties of the coin, such as its weight or shape. This could also result in a bias towards one side or the other.

import random
import matplotlib.pyplot as plt

print("Welcome to a coin flip simulation!")
print("----------------------------------")

n = 10000 #this value can easily be changed to change the sample size
heads = 0
tails = 0
 
for i in range(n): # loops through 10000 coin flips 
    flip = random.randint(1,2) # get a random number between 1 and 2
    if flip == 1: # head
        heads = heads + 1
    else:         # tail
        tails = tails + 1

# Create a pie chart to visualize the results
labels = ['Heads', 'Tails'] 
sizes = [heads, tails]# list that holds heads and tails  
colors = ['lightblue', 'lightgreen'] # light blue is heads and light green is tails
#matplotlib makes the pie graph 
plt.pie(sizes, colors=colors, labels=labels, autopct='%1.1f%%', startangle=90)
plt.axis('equal')
plt.title('Coin Flip Simulation Results')
plt.show()

# print the coin numbers 
print('Number of heads:', heads)
print('Number of tails:', tails)
Welcome to a coin flip simulation!
----------------------------------
Number of heads: 4907
Number of tails: 5093

Simulation Questions

  1. A and B
  2. A
  3. A
  4. D
  5. B and D
  6. C

Bonus

image