Simulation Using R Programming

Simulation is a powerful technique in statistics and data analysis, used to model complex systems, understand random processes, and predict outcomes. In R, various packages and functions facilitate simulation studies.

Introduction to Simulation in R

Simulating scenarios is a powerful tool for making informed decisions and exploring potential outcomes without the need for real-world experimentation. This article delves into the world of simulation using R Programming Language versatile programming language widely used for statistical computing and graphics. We'll equip you with the knowledge and code examples to craft effective simulations in R, empowering you to:

• Predict the Unpredictable: Explore "what-if" scenarios by simulating various conditions within your system or process.
• Test Hypotheses with Confidence: Analyze the behavior of your system under different circumstances to validate or challenge your assumptions.
• Estimate Parameters with Precision: Evaluate the impact of changing variables on outcomes, allowing for more accurate parameter estimation.
• Forecast Trends for Informed Decisions: Leverage simulated data to predict future behavior and make data-driven choices for your system or process.

Types of Simulations

This article will walk you through the basics of simulation in R, covering different types of simulations and practical examples.

1. Monte Carlo Simulation: Uses random sampling to compute results and is commonly used for numerical integration and risk analysis.
2. Discrete Event Simulation: Models the operation of systems as a sequence of events in time.
3. Agent-Based Simulation: Simulates the actions and interactions of autonomous agents to assess their effects on the system.

Let's start with a simple Monte Carlo simulation to estimate the value of π.

Estimating π Using Monte Carlo Simulation

The idea is to randomly generate points in a unit square and count how many fall inside the unit circle. The ratio of points inside the circle to the total number of points approximates π/4.

# Number of points to generate
n <- 10000

# Generate random points
set.seed(123)
x <- runif(n)
y <- runif(n)

# Calculate distance from (0,0) and check if inside the unit circle
inside <- x^2 + y^2 <= 1

# Estimate π
pi_estimate <- (sum(inside) / n) * 4
pi_estimate

# Plot the points
plot(x, y, col = ifelse(inside, 'blue', 'red'), pch = 19, cex = 0.5,
     main = paste("Estimation of π =", round(pi_estimate, 4)),
     xlab = "X", ylab = "Y")

Output:

• runif(n): Generates n random numbers uniformly distributed between 0 and 1.
• inside: Logical vector indicating whether each point lies inside the unit circle.
• sum(inside) / n * 4: Estimates π using the ratio of points inside the circle to total points.

Simulating a Normal Distribution

Simulating data from a normal distribution is straightforward with R's rnorm() function. Let's simulate 1000 data points from a normal distribution with a mean of 50 and a standard deviation of 10.

# Parameters
mean <- 50
sd <- 10
n <- 1000

# Simulate data
set.seed(123)
data <- rnorm(n, mean = mean, sd = sd)

# Plot the histogram
hist(data, breaks = 30, col = "lightblue", main = "Histogram of Simulated Normal Data",
     xlab = "Value", ylab = "Frequency")

# Add a density curve
lines(density(data), col = "red", lwd = 2)

Output:

• rnorm(n, mean, sd): Generates n random numbers from a normal distribution with specified mean and sd.
• hist(): Plots a histogram of the simulated data.
• lines(density(data)): Adds a kernel density estimate to the histogram.

Discrete Event Simulation

Let's simulate the operation of a simple queue system using the simmer package.

# Install and load simmer package
install.packages("simmer")
library(simmer)

# Define a simple queueing system
env <- simmer("queueing_system")

# Define arrival and service processes
arrival <- trajectory("arrival") %>%
  seize("server", 1) %>%
  timeout(function() rexp(1, 1/10)) %>%
  release("server", 1)

# Add resources and arrivals to the environment
env %>%
  add_resource("server", 1) %>%
  add_generator("customer", arrival, function() rexp(1, 1/5))

# Run the simulation for a specified period
env %>%
  run(until = 100)

# Extract and plot results
arrivals <- get_mon_arrivals(env)
hist(arrivals$end_time - arrivals$start_time, breaks = 30, col = "lightgreen",
     main = "Histogram of Customer Waiting Times",
     xlab = "Waiting Time", ylab = "Frequency")

Output:

simmer environment: queueing_system | now: 100 | next: 100.308581297463
{ Monitor: in memory }
{ Resource: server | monitored: TRUE | server status: 1(1) | queue status: 7(Inf) }
{ Source: customer | monitored: 1 | n_generated: 17 }

• simmer("queueing_system"): Creates a new simulation environment.
• trajectory(): Defines the sequence of operations for arriving customers.
• seize(), timeout(), release(): Define the customer actions (seizing a server, spending time being served, and releasing the server).
• add_resource(), add_generator(): Add resources (servers) and customer arrival processes to the environment.
• run(until = 100): Runs the simulation for 100 time units.
• get_mon_arrivals(): Extracts arrival data for analysis.

Conclusion

Simulation in R is a versatile tool that can be applied to various fields, from statistical estimation to system modeling and risk analysis. By leveraging R's robust functions and packages like simmer, you can build and analyze complex simulation models to gain insights and make informed decisions. The examples provided illustrate the basic concepts and methods for conducting simulations, which can be expanded and customized to suit specific needs and scenarios.