Vectorization vs loops in MATLAB - Performance Comparison

Time Complexity: Vectorization vs loops

O(n)

Understanding Time Complexity

We want to see how using vectorization or loops affects how long a MATLAB program takes to run.

How does the time needed change when we do the same task with loops versus vectorized code?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

n = 1000;
result = zeros(1,n);
for i = 1:n
    result(i) = i^2;
end

% Vectorized version
result_vec = (1:n).^2;

This code calculates the squares of numbers from 1 to n using a loop and then using vectorization.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Loop runs from 1 to n, doing one multiplication each time.
• How many times: The loop runs exactly n times.
• Vectorized operation: The whole array is squared in one step without explicit looping.

How Execution Grows With Input

Explain the growth pattern intuitively.

Input Size (n)	Approx. Operations (Loop)	Approx. Operations (Vectorized)
10	10 multiplications	1 vector operation on 10 elements
100	100 multiplications	1 vector operation on 100 elements
1000	1000 multiplications	1 vector operation on 1000 elements

Pattern observation: The loop does more steps as n grows, while vectorization handles all at once, so it grows slower in time.

Final Time Complexity

Time Complexity: O(n)

This means the time grows in a straight line with the number of elements when using loops, but vectorization can be faster by doing many operations together.

Common Mistake

[X] Wrong: "Vectorization always means the program runs in constant time no matter how big n is."

[OK] Correct: Vectorization still processes all elements, so time grows with n, but it uses faster internal operations than loops.

Interview Connect

Understanding how loops and vectorization affect time helps you write faster MATLAB code and shows you can think about efficiency clearly.

Self-Check

"What if we replaced the loop with a nested loop that squares numbers in a 2D matrix? How would the time complexity change?"

Practice

1. Which of the following best describes vectorization in MATLAB?

easy

A. Writing functions that call themselves recursively

B. Using nested for loops to process each element individually

C. Manually indexing each element to apply operations

D. Performing operations on entire arrays at once without explicit loops

Solution

1. Step 1: Understand vectorization concept

   Vectorization means applying operations to whole arrays at once, avoiding explicit loops.

2. Step 2: Compare options

   Only Performing operations on entire arrays at once without explicit loops describes this correctly; others describe loops or recursion.

3. Final Answer:

   Performing operations on entire arrays at once without explicit loops -> Option D

4. Quick Check:

   Vectorization = whole-array operations [OK]

Hint: Vectorization means no loops, operate on full arrays [OK]

Common Mistakes:

• Confusing vectorization with loops
• Thinking recursion is vectorization
• Assuming manual indexing is vectorization

2. Which MATLAB syntax correctly sums all elements of a vector A using vectorization?

easy

A. sum = 0; for i = 1:length(A); sum = sum + A(i); end

B. sum = A + A;

C. sum = sum(A);

D. sum = A(1) + A(2);

Solution

1. Step 1: Identify vectorized sum syntax

   MATLAB's built-in sum() function sums all elements of an array directly.

2. Step 2: Check options

   sum = sum(A); uses sum(A), which is vectorized. sum = 0; for i = 1:length(A); sum = sum + A(i); end uses a loop. sum = A + A; adds vector to itself. sum = A(1) + A(2); sums only two elements.

3. Final Answer:

   sum = sum(A); -> Option C

4. Quick Check:

   sum(A) sums all elements vectorized [OK]

Hint: Use built-in sum() for vectorized addition [OK]

Common Mistakes:

• Using loops instead of sum()
• Adding vector to itself instead of summing
• Summing only part of the vector

3. What is the output of this MATLAB code?

A = [1, 2, 3, 4]; B = A .* 2;

medium

A. [1, 4, 9, 16]

B. [2, 4, 6, 8]

C. [3, 4, 5, 6]

D. Error: Matrix dimensions must agree

Solution

1. Step 1: Understand element-wise multiplication

   The operator .* multiplies each element of A by 2 individually.

2. Step 2: Calculate each element

   1*2=2, 2*2=4, 3*2=6, 4*2=8, so B = [2, 4, 6, 8].

3. Final Answer:

   [2, 4, 6, 8] -> Option B

4. Quick Check:

   Element-wise multiply by 2 = [2,4,6,8] [OK]

Hint: .* multiplies each element individually [OK]

Common Mistakes:

• Confusing .* with matrix multiplication (*)
• Expecting squared values instead of doubled
• Thinking it causes dimension errors

4. Identify the error in this MATLAB code that tries to double each element of vector A:

A = [1, 2, 3]; for i = 1:length(A); A = A * 2; end

medium

A. The loop variable i is not used inside the loop

B. Using * instead of .* causes dimension mismatch

C. The vector A is not initialized

D. The loop range is incorrect

Solution

1. Step 1: Analyze the loop body

   The code multiplies entire vector A by 2 each iteration, ignoring i.

2. Step 2: Understand the effect

   Since i is unused, the loop repeats the same operation, scaling A multiple times (by 8 total) instead of doubling individual elements via indexing.

3. Final Answer:

   The loop variable i is not used inside the loop -> Option A

4. Quick Check:

   Loop variable unused causes logic error [OK]

Hint: Use loop variable to index elements inside loop [OK]

Common Mistakes:

• Ignoring loop variable usage
• Confusing * and .* operators
• Assuming vector auto-updates element-wise

5. You want to compute the square of each element in a large vector X efficiently. Which MATLAB code snippet uses vectorization correctly?

hard

A. Y = X .* X;

B. Y = zeros(size(X)); for i = 1:length(X); Y = X(i)^2; end

C. Y = X ^ 2;

D. for i = 1:length(X); Y(i) = X(i)^2; end

Solution

1. Step 1: Understand vectorized squaring

   Element-wise multiplication .* between X and X squares each element efficiently.

2. Step 2: Check each option

   for i = 1:length(X); Y(i) = X(i)^2; end uses a loop (less efficient). Y = zeros(size(X)); for i = 1:length(X); Y = X(i)^2; end overwrites Y with a scalar each iteration. Y = X ^ 2; attempts invalid matrix power for vectors. Y = X .* X; is correct.

3. Final Answer:

   Y = X .* X; -> Option A

4. Quick Check:

   Element-wise multiply vector by itself = square [OK]

Hint: Use .* to square vectors element-wise [OK]

Common Mistakes:

• Using ^ instead of .^ or .* for element-wise power
• Overwriting output inside loop
• Using loops instead of vectorization