Programming |

**Techniques for Improving Performance**

This section covers the following suggestions on how you can improve the performance of your MATLAB programs:

- Vectorizing Loops
- Preallocating Arrays
- Coding Loops in a MEX-File
- Assigning to Variables
- Operating on Real Data
- Using Appropriate Logical Operators
- Overloading Built-In Functions
- Functions Are Generally Faster Than Scripts
- Load and Save Are Faster Than File I/O Functions
- Avoid Large Background Processes

MATLAB is a matrix language, which means it is designed for vector and matrix operations. You can often speed up your M-file code by using vectorizing algorithms that take advantage of this design. *Vectorization* means converting `for`

and `while`

loops to equivalent vector or matrix operations.

**Simple Example of Vectorizing**

Here is one way to compute the sine of 1001 values ranging from 0 to 10:

A vectorized version of the same code is

The second example executes much faster than the first and is the way MATLAB is meant to be used. Test this on your system by creating M-file scripts that contain the code shown, and then using the `tic`

and `toc`

functions to time the M-files.

**Advanced Example of Vectorizing**

`repmat`

is an example of a function that takes advantage of vectorization. It accepts three input arguments: an array `A`

, a row dimension `M`

, and a column dimension `N`

.

`repmat`

creates an output array that contains the elements of array `A`

, replicated and "tiled" in an `M`

-by-`N`

arrangement:

A = [1 2 3; 4 5 6]; B = repmat(A,2,3); B = 1 2 3 1 2 3 1 2 3 4 5 6 4 5 6 4 5 6 1 2 3 1 2 3 1 2 3 4 5 6 4 5 6 4 5 6

`repmat`

uses vectorization to create the indices that place elements in the output array:

function B = repmat(A, M, N) %

**Step 1**Get row and column sizes [m,n] = size(A); %**Step 2**Generate vectors of indices from 1 to row/column size mind = (1:m)'; nind = (1:n)'; %**Step 3**Create index matrices from vectors above mind = mind(:,ones(1, M)); nind = nind(:,ones(1, N)); %**Step 4**Create output array B = A(mind,nind);

**Step 1**, above, obtains the row and column sizes of the input array.

**Step 2** creates two column vectors. `mind`

contains the integers from 1 through the row size of `A`

. The `nind`

variable contains the integers from 1 through the column size of `A`

.

**Step 3** uses a MATLAB vectorization trick to replicate a single column of data through any number of columns. The code is

where `nCols`

is the desired number of columns in the resulting matrix.

**Step 4** uses array indexing to create the output array. Each element of the row index array, `mind`

, is paired with each element of the column index array, `nind`

, using the following procedure:

- The first element of
`mind`

, the row index, is paired with each element of`nind`

. MATLAB moves through the`nind`

matrix in a columnwise fashion, so`mind(1,1)`

goes with`nind(1,1)`

, and then`nind(2,1)`

, and so on. The result fills the first row of the output array. - Moving columnwise through
`mind`

, each element is paired with the elements of`nind`

as above. Each complete pass through the`nind`

matrix fills one row of the output array.

**Functions Used in Vectorizing**

Some of the most commonly used functions for vectorizing are as follows

Function |
Description |

`all` |
Test to determine if all elements are nonzero |

`any` |
Test for any nonzeros |

`cumsum` |
Find cumulative sum |

`diff` |
Find differences and approximate derivatives |

`find` |
Find indices and values of nonzero elements |

`ind2sub` |
Convert from linear index to subscripts |

`ipermute` |
Inverse permute dimensions of a multidimensional array |

`logical` |
Convert numeric values to logical |

`ndgrid` |
Generate arrays for multidimensional functions and interpolation |

`permute` |
Rearrange dimensions of a multidimensional array |

`prod` |
Find product of array elements |

`repmat` |
Replicate and tile an array |

`reshape` |
Change the shape of an array |

`shiftdim` |
Shift array dimensions |

`sort` |
Sort array elements in ascending or descending order |

`squeeze` |
Remove singleton dimensions from an array |

`sub2ind` |
Convert from subscripts to linear index |

`sum` |
Find the sum of array elements |

Analyzing Your Program's Performance | Preallocating Arrays |

© 1994-2005 The MathWorks, Inc.