Vectorization vs loops in MATLAB

Introduction

Vectorization helps you do many calculations at once, making your code faster and simpler. Loops do one step at a time, which can be slower.

When you want to add two lists of numbers quickly.

When you need to apply the same math to every item in a big list.

When you want your program to run faster by avoiding repeated steps.

When you want your code to be shorter and easier to read.

When working with large data sets like images or signals.

Syntax

MATLAB

Loop example:
for i = 1:length(A)
    B(i) = A(i) * 2;
end

Vectorized example:
B = A .* 2;

Loops repeat commands for each item one by one.

Vectorization applies operations to whole arrays at once.

Examples

This loop squares each element of A one by one.

MATLAB

A = [1, 2, 3, 4];
B = zeros(size(A));
for i = 1:length(A)
    B(i) = A(i)^2;
end

This vectorized code squares all elements of A at once.

MATLAB

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

Loop with condition: multiply elements greater than 2 by 10.

MATLAB

A = [1, 2, 3, 4];
B = zeros(size(A));
for i = 1:length(A)
    if A(i) > 2
        B(i) = A(i) * 10;
    else
        B(i) = A(i);
    end
end

Vectorized version with condition using logical indexing.

MATLAB

A = [1, 2, 3, 4];
B = A;
B(A > 2) = A(A > 2) * 10;

Sample Program

This program shows how to double numbers in a list using a loop and vectorization. Both give the same result, but vectorization is simpler.

MATLAB

A = 1:5;

% Using loop to double each element
B_loop = zeros(size(A));
for i = 1:length(A)
    B_loop(i) = A(i) * 2;
end

% Using vectorization to double each element
B_vector = A .* 2;

% Display results
fprintf('Using loop: ');
fprintf('%d ', B_loop);
fprintf('\nUsing vectorization: ');
fprintf('%d ', B_vector);
fprintf('\n');

Important Notes

Vectorized code usually runs faster in MATLAB because it uses optimized math operations.

Loops are easier to understand for beginners but can be slower for big data.

Use vectorization when possible, but loops are fine for complex steps that can't be vectorized.

Summary

Vectorization applies operations to whole arrays at once, making code faster and shorter.

Loops repeat commands step-by-step and can be slower but are sometimes necessary.

In MATLAB, prefer vectorization for better performance and cleaner code.

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