Running simulations in MATLAB - Deep Dive

Overview - Running simulations

What is it?

Running simulations means using a computer to imitate real-world processes or systems many times. It helps us see what might happen under different conditions without doing real experiments. In MATLAB, simulations use code to model these processes step-by-step. This lets us study complex problems safely and quickly.

Why it matters

Simulations let us test ideas and predict outcomes without costly or risky real-world trials. Without simulations, we would rely only on guesswork or slow experiments, making it hard to understand complex systems like weather, finance, or engineering. Simulations save time, money, and help make better decisions.

Where it fits

Before running simulations, you should understand basic MATLAB programming and how to write functions. Knowing simple math and statistics helps too. After learning simulations, you can explore advanced modeling, optimization, or machine learning to analyze and improve systems.

Mental Model

Core Idea

Running simulations is like creating a virtual experiment that repeats many times to explore possible outcomes.

Think of it like...

Imagine testing a new recipe by cooking it many times with slight changes to ingredients and cooking time to see which tastes best, without wasting real food each time.

┌───────────────┐
│ Define Model  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Set Parameters│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Run Simulation│
│ (repeat many) │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Collect Data  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Analyze Result│
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding simulation basics

Concept: Simulations imitate real processes by repeating steps with different inputs.

A simulation runs a model many times, each time with different values to see how the output changes. For example, simulating coin tosses means randomly choosing heads or tails many times to see the chance of each outcome.

Result

You get a set of results showing how the system behaves under different conditions.

Understanding that simulations explore many possible scenarios helps grasp why they are powerful for studying uncertainty.

2

Foundation

Writing simple MATLAB simulation code

Concept: Use loops and random functions in MATLAB to run repeated trials.

In MATLAB, you can use a for-loop to repeat an experiment. For example, tossing a coin 100 times can be coded using randi to generate random 1s or 2s representing heads or tails.

Result

You get an array of results representing each trial's outcome.

Knowing how to write loops and use randomness is the foundation for building any simulation.

3

Intermediate

Parameterizing simulations for flexibility

🤔Before reading on: Do you think changing parameters inside a simulation requires rewriting the whole code or just adjusting inputs? Commit to your answer.

Concept: Design simulations so you can easily change inputs without changing the core code.

Create functions that accept parameters like number of trials or probabilities. This way, you can run the same simulation with different settings by just changing the inputs.

Result

You can quickly test many scenarios by calling the function with different parameters.

Separating model logic from parameters makes simulations reusable and easier to explore.

4

Intermediate

Collecting and storing simulation results

Concept: Store outputs from each simulation run in arrays or tables for analysis.

Inside the loop, save each trial's result in a pre-allocated array. After all runs, you can calculate statistics like mean, variance, or plot histograms.

Result

You have organized data ready for analysis and visualization.

Properly collecting data during simulations is key to making sense of the results.

5

Intermediate

Visualizing simulation outcomes

🤔Before reading on: Do you think raw numbers alone are enough to understand simulation results or are visualizations necessary? Commit to your answer.

Concept: Use MATLAB plotting functions to see patterns and distributions in results.

Plot histograms, line plots, or scatter plots to show how results vary. For example, a histogram of coin toss outcomes shows the frequency of heads and tails.

Result

Visual graphs that reveal trends and variability in the simulation data.

Visualizing results helps detect patterns and communicate findings clearly.

6

Advanced

Running stochastic simulations with randomness

🤔Before reading on: Do you think randomness in simulations always leads to the same results each time? Commit to your answer.

Concept: Simulations often include random elements to mimic uncertainty, requiring multiple runs to understand variability.

Use MATLAB's random number generators with different seeds to produce varied outcomes. Run simulations many times and analyze the distribution of results to estimate probabilities.

Result

A range of possible outcomes showing the effect of randomness on the system.

Understanding randomness and repeated runs is essential to capture real-world uncertainty in simulations.

7

Expert

Optimizing simulations for speed and accuracy

🤔Before reading on: Do you think running more simulation trials always improves accuracy without downsides? Commit to your answer.

Concept: Balancing the number of runs and computational resources is critical for practical simulations.

Use vectorized code, pre-allocate memory, and parallel computing in MATLAB to speed up simulations. Also, know when more runs add little accuracy to avoid wasting time.

Result

Efficient simulations that produce reliable results faster.

Knowing how to optimize simulations prevents slow code and wasted resources while maintaining result quality.

Under the Hood

Simulations run models step-by-step, often inside loops, using random or fixed inputs. MATLAB executes these instructions sequentially, storing outputs in memory. Random number generators produce pseudo-random values based on initial seeds, ensuring repeatability if needed. Data structures like arrays hold results for later analysis.

Why designed this way?

Simulations were designed to mimic experiments without physical trials. Using loops and random generators allows flexible, repeatable tests. MATLAB's matrix-based design supports fast numerical operations, making it ideal for simulations. Alternatives like manual calculations or physical experiments are slower, costly, or impossible for complex systems.

┌───────────────┐
│ Start Program │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Initialize    │
│ Parameters    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Loop over     │
│ Trials        │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Generate      │
│ Random Inputs │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Compute Model │
│ Output        │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Store Results │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Analyze &     │
│ Visualize     │
└───────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Do you think running a simulation once gives a reliable answer? Commit to yes or no.

Common Belief: Running a simulation a single time is enough to understand the system's behavior.

Reality: Because simulations often include randomness, one run shows only one possible outcome. Multiple runs are needed to see the range of possibilities.

Why it matters: Relying on one run can lead to wrong conclusions and poor decisions because it ignores variability.

Quick: Do you think simulations always perfectly predict real-world outcomes? Commit to yes or no.

Common Belief: Simulations give exact predictions of what will happen in reality.

Reality: Simulations are simplified models and approximations; they provide estimates, not exact answers.

Why it matters: Overtrusting simulations can cause surprises if real systems behave differently due to unknown factors.

Quick: Do you think more simulation runs always improve accuracy without limits? Commit to yes or no.

Common Belief: Increasing the number of simulation runs indefinitely always improves result accuracy.

Reality: After a point, more runs add little accuracy but increase computation time and cost.

Why it matters: Ignoring this leads to inefficient use of resources and slower analysis.

Expert Zone

1

Random number generator seeds control reproducibility; changing seeds changes outcomes but keeps the process consistent.

2

Vectorizing simulation code in MATLAB can drastically speed up runs compared to loops.

3

Parallel computing allows running multiple simulation trials simultaneously, saving time on large experiments.

When NOT to use

Simulations are not ideal when exact analytical solutions exist or when data is abundant for direct statistical modeling. In such cases, use mathematical formulas or machine learning models instead.

Production Patterns

Professionals use simulations for risk analysis, system design testing, and forecasting. They integrate simulations with optimization algorithms to find best parameters and use automated scripts to run large batches on computing clusters.

Connections

Monte Carlo methods

Simulations often use Monte Carlo techniques to estimate probabilities by random sampling.

Understanding simulations helps grasp how Monte Carlo methods approximate complex integrals or distributions.

Experimental design

Simulations mimic experiments by systematically varying inputs to study effects.

Knowing simulations clarifies how to plan real experiments and interpret their variability.

Financial risk management

Simulations model uncertain market behaviors to estimate risks and potential losses.

Learning simulations reveals how finance professionals predict rare events and prepare for uncertainty.

Common Pitfalls

#1 Running simulation without pre-allocating arrays causes slow performance.

Wrong approach:

results = [];
for i = 1:10000
results = [results, rand()];
end

Correct approach:

results = zeros(1,10000);
for i = 1:10000
results(i) = rand();
end

Root cause:

Appending inside loops reallocates memory each time, slowing down execution.

#2 Using the same random seed for every simulation run hides variability.

Wrong approach:

rng(1);
for i = 1:100
val = rand();
disp(val);
end

Correct approach:

rng('shuffle');
for i = 1:100
val = rand();
disp(val);
end

Root cause:

Fixing the seed causes the random number generator to produce the same sequence every time.

#3 Ignoring the need for multiple runs when randomness is involved.

Wrong approach:

val = rand();
disp(val); % Single run

Correct approach:

vals = zeros(1,1000);
for i = 1:1000
vals(i) = rand();
end
disp(mean(vals));

Root cause:

One run does not capture the distribution or variability of outcomes.

Key Takeaways

Simulations let us explore many possible outcomes by repeating virtual experiments with different inputs.

Writing flexible, parameterized MATLAB code makes simulations reusable and easier to test under varied conditions.

Randomness in simulations requires multiple runs to understand the range and likelihood of results.

Efficient coding and proper data collection during simulations are essential for fast and meaningful analysis.

Simulations are approximations, not exact predictions, so understanding their limits is key to using them wisely.

Practice

1. What is the main purpose of using a for loop in running simulations in MATLAB?

easy

A. To repeat a set of commands multiple times automatically

B. To create graphical user interfaces

C. To store data permanently on disk

D. To define new functions

Solution

1. Step 1: Understand the role of for loops

   A for loop repeats commands a fixed number of times, which is essential for running simulations step-by-step.

2. Step 2: Match the purpose to simulation needs

   Simulations require repeating calculations or processes many times to model changes over time, which for loops handle well.

3. Final Answer:

   To repeat a set of commands multiple times automatically -> Option A

4. Quick Check:

   Loop repeats commands = repeat steps [OK]

Hint: Loops repeat steps automatically, perfect for simulations [OK]

Common Mistakes:

• Confusing loops with data storage
• Thinking loops create GUIs
• Mixing loops with function definitions

2. Which of the following is the correct syntax to run a simulation loop 10 times in MATLAB?

easy

A. repeat 10 times
% simulation code
endrepeat

B. for i = 1:10
% simulation code
end

C. loop i = 1 to 10
% simulation code
endloop

D. while i < 10
% simulation code
end

Solution

1. Step 1: Recall MATLAB for loop syntax

   MATLAB uses for variable = start:end to run loops a fixed number of times.

2. Step 2: Compare options with correct syntax

   for i = 1:10 % simulation code end matches MATLAB syntax exactly; others use incorrect keywords or structures.

3. Final Answer:

   for i = 1:10 % simulation code end -> Option B

4. Quick Check:

   MATLAB loops use 'for i = start:end' [OK]

Hint: MATLAB loops use 'for i = start:end' syntax [OK]

Common Mistakes:

• Using non-MATLAB keywords like 'loop' or 'repeat'
• Confusing while with for loops
• Missing the end keyword

3. What will be the output of the following MATLAB code?

for t = 1:3
  disp(t^2)
end

medium

A. 1 4 9

B. 1 2 3

C. 2 4 6

D. Error: Undefined function

Solution

1. Step 1: Understand the loop iterations

   The loop runs with t = 1, 2, 3.

2. Step 2: Calculate the displayed values

   Each iteration displays t squared: 1^2=1, 2^2=4, 3^2=9.

3. Final Answer:

   1 4 9 -> Option A

4. Quick Check:

   Squares of 1,2,3 = 1 4 9 [OK]

Hint: Square each loop index to find output quickly [OK]

Common Mistakes:

• Printing t instead of t squared
• Confusing output with sums
• Expecting syntax errors

4. Identify the error in this MATLAB simulation code:

for i = 1:5
  result = i * 2
end
disp(result)

medium

A. Missing semicolon after result assignment

B. The loop variable 'i' is not initialized

C. No error; code runs and displays the last result

D. Variable 'result' is not defined before the loop

Solution

1. Step 1: Check variable initialization

   In MATLAB, variables can be created inside loops without prior definition.

2. Step 2: Understand loop and output behavior

   The loop runs 5 times, updating 'result' each time; after loop, 'result' holds last value (5*2=10), which is displayed.

3. Final Answer:

   No error; code runs and displays the last result -> Option C

4. Quick Check:

   Loop updates variable; last value shown [OK]

Hint: Variables inside loops update each iteration; last value remains [OK]

Common Mistakes:

• Thinking semicolons are mandatory to avoid errors
• Assuming variables must be pre-declared
• Confusing loop variable initialization

5. You want to simulate the growth of a population starting at 100, increasing by 10% each step, for 5 steps. Which MATLAB code correctly runs this simulation and stores all population values in an array pop?

hard

A. pop = zeros(5,1);
pop(1) = 100;
for i = 1:5
pop(i+1) = pop(i) * 1.1;
end

B. pop = 100;
for i = 1:5
pop = pop * 1.1;
end

C. pop = [];
for i = 1:5
pop(i) = 100 * 1.1^i;
end

D. pop = zeros(1,5);
pop(1) = 100;
for i = 2:5
pop(i) = pop(i-1) * 1.1;
end

Solution

1. Step 1: Understand the simulation requirements

   Start at 100, increase by 10% each step, store all 5 values in an array.

2. Step 2: Analyze each option for correctness

   pop = zeros(1,5); pop(1) = 100; for i = 2:5 pop(i) = pop(i-1) * 1.1; end initializes array, sets first value, then correctly updates subsequent values using previous step's value. pop = 100; for i = 1:5 pop = pop * 1.1; end overwrites single value, no array. pop = []; for i = 1:5 pop(i) = 100 * 1.1^i; end calculates powers but starts from step 1, missing initial 100 at index 1. pop = zeros(5,1); pop(1) = 100; for i = 1:5 pop(i+1) = pop(i) * 1.1; end tries to access index 6 in 5-element array, causing error.

3. Final Answer:

   pop = zeros(1,5); pop(1) = 100; for i = 2:5 pop(i) = pop(i-1) * 1.1; end -> Option D

4. Quick Check:

   Initialize array, set first value, update from previous [OK]

Hint: Initialize array, set first value, update from previous step [OK]

Common Mistakes:

• Not storing all values in an array
• Indexing beyond array size
• Overwriting single variable instead of array