matlab-performance-optimizer

# MATLAB Performance Optimizer

Optimize MATLAB code performance with vectorization, memory management, and profiling tools.

## When to Use This Skill

- Optimizing slow or inefficient MATLAB code
- Converting loops to vectorized operations
- Reducing memory usage
- Improving algorithm performance
- When user mentions: slow, performance, optimize, speed up, efficient, memory
- Profiling code to find bottlenecks
- Parallelizing computations

## Core Optimization Principles

### 1. Vectorization (Most Important)

**Replace loops with vectorized operations whenever possible.**

**SLOW - Using loops:**
```matlab
% Slow approach
n = 1000000;
result = zeros(n, 1);
for i = 1:n
    result(i) = sin(i) * cos(i);
end
```

**FAST - Vectorized:**
```matlab
% Fast approach
n = 1000000;
i = (1:n).';
result = sin(i) .* cos(i);
```

### 2. Preallocate Arrays

**Always preallocate arrays before loops.**

**SLOW - Growing arrays:**
```matlab
% Very slow - array grows each iteration
result = [];
for i = 1:10000
    result(end+1) = i^2;
end
```

**FAST - Preallocated:**
```matlab
% Fast - preallocated array
n = 10000;
result = zeros(n, 1);
for i = 1:n
    result(i) = i^2;
end
```

### 3. Use Built-in Functions

**MATLAB built-in functions are highly optimized.**

**SLOW - Manual implementation:**
```matlab
% Slow
sum_val = 0;
for i = 1:length(x)
    sum_val = sum_val + x(i);
end
```

**FAST - Built-in function:**
```matlab
% Fast
sum_val = sum(x);
```

## Vectorization Techniques

### Element-wise Operations

Use `.*`, `./`, `.^` for element-wise operations:

```matlab
% Instead of this:
for i = 1:length(x)
    y(i) = x(i)^2 + 2*x(i) + 1;
end

% Do this:
y = x.^2 + 2*x + 1;
```

### Logical Indexing

Replace conditional loops with logical indexing:

```matlab
% Instead of this:
count = 0;
for i = 1:length(data)
    if data(i) > threshold
        count = count + 1;
        filtered(count) = data(i);
    end
end
filtered = filtered(1:count);

% Do this:
filtered = data(data > threshold);
```

### Matrix Operations

Use matrix multiplication instead of nested loops:

```matlab
% Instead of this:
C = zeros(size(A, 1), size(B, 2));
for i = 1:size(A, 1)
    for j = 1:size(B, 2)
        for k = 1:size(A, 2)
            C(i,j) = C(i,j) + A(i,k) * B(k,j);
        end
    end
end

% Do this:
C = A * B;
```

### Cumulative Operations

Use `cumsum`, `cumprod`, `cummax`, `cummin`:

```matlab
% Instead of this:
running_sum = zeros(size(data));
running_sum(1) = data(1);
for i = 2:length(data)
    running_sum(i) = running_sum(i-1) + data(i);
end

% Do this:
running_sum = cumsum(data);
```

## Memory Optimization

### Use Appropriate Data Types

```matlab
% Instead of default double (8 bytes)
data = rand(1000, 1000);  % 8 MB

% Use single precision when appropriate (4 bytes)
data = single(rand(1000, 1000));  % 4 MB

% Use integers when applicable
indices = uint32(1:1000000);  % 4 MB instead of 8 MB
```

### Sparse Matrices

For matrices with mostly zeros:

```matlab
% Dense matrix (wastes memory)
A = zeros(10000, 10000);
A(1:100, 1:100) = rand(100);  % 800 MB

% Sparse matrix (efficient)
A = sparse(10000, 10000);
A(1:100, 1:100) = rand(100);  % Only stores non-zeros
```

### Clear Unused Variables

```matlab
% Process large data
largeData = loadData();
processedData = processData(largeData);

% Clear when no longer needed
clear largeData;

% Continue with processed data
results = analyze(processedData);
```

### In-Place Operations

```matlab
% Instead of creating copies
A = A + 5;  % In-place when possible

% Avoid unnecessary copies
B = A;      % Creates copy if A is modified later
B = A + 0;  % Forces copy
```

## Profiling and Benchmarking

### Using the Profiler

```matlab
% Profile code execution
profile on
myFunction(inputs);
profile viewer
profile off
```

The profiler shows:
- Time spent in each function
- Number of calls to each function
- Lines that take the most time

### Timing Comparisons

```matlab
% Time single execution
tic;
result = myFunction(data);
elapsedTime = toc;

% Benchmark with timeit (more accurate)
timeit(@() myFunction(data))

% Compare multiple approaches
time1 = timeit(@() approach1(data));
time2 = timeit(@() approach2(data));
fprintf('Approach 1: %.6f s\nApproach 2: %.6f s\n', time1, time2);
```

## Common Optimization Patterns

### Pattern 1: Replace find with Logical Indexing

```matlab
% SLOW
indices = find(x > 5);
y = x(indices);

% FAST
y = x(x > 5);
```

### Pattern 2: Use Implicit Expansion Instead of repmat

```matlab
% SLOW - repmat to match dimensions
A = rand(1000, 5);
B = rand(1, 5);
C = A - repmat(B, size(A, 1), 1);

% FAST - implicit expansion (R2016b+)
C = A - B;
```

### Pattern 3: Avoid Repeated Calculations

```matlab
% SLOW - recalculates each iteration
for i = 1:n
    result(i) = data(i) / sqrt(sum(data.^2));
end

% FAST - calculate once
norm_factor = sqrt(sum(data.^2));
for i = 1:n
    result(i) = data(i) / norm_factor;
end

% EVEN FASTER - vectorize
result = data / sqrt(sum(data.^2));
```

### Pattern 4: Efficient String Operations

```matlab
% SLOW - concatenating in loop
str = '';
for i = 1:1000
    str = [str, sprintf('Line %d\n', i)];
end

% FAST - cell array + join
lines = cell(1000, 1);
for i = 1:1000
    lines{i} = sprintf('Line %d', i);
end
str = strjoin(lines, '\n');

% FASTEST - vectorized sprintf
str = sprintf('Line %d\n', 1:1000);
```

### Pattern 5: Use Table for Mixed Data Types

```matlab
% Instead of separate arrays
names = cell(1000, 1);
ages = zeros(1000, 1);
scores = zeros(1000, 1);

% Use table
data = table(names, ages, scores);
% Faster access and better organization
```

## Algorithm-Specific Optimizations

### Convolution and Filtering

```matlab
% Use built-in functions
filtered = conv(signal, kernel, 'same');
filtered = filter(b, a, signal);

% For 2D
filtered = conv2(image, kernel, 'same');
filtered = imfilter(image, kernel);

% FFT-based for large kernels (zero-pad for linear convolution)
nfft = length(signal) + length(kernel) - 1;
filtered =