MATLAB PROGRAMMING TIPS

Introduction

This section is a categorized compilation of tips for the MATLAB programmer. Each item is relatively brief to help you browse through them and find information that is useful. Many of the tips include a reference to specific MATLAB documentation that gives you more complete coverage of the topic. You can find information on the following topics:
For suggestions on how to improve the performance of your MATLAB programs, and how to write programs that use memory more efficiently, see Improving Performance and Memory Usage

Syntax Help

For help about the general syntax of MATLAB functions and commands, type

help syntax

Command and Function Syntaxes

You can enter MATLAB commands using either a command or function syntax. It is important to learn the restrictions and interpretation rules for both.

functionname arg1 arg2 arg3               % Command syntax
functionname('arg1','arg2','arg3')        % Function syntax

For more information: See Calling Functions in the MATLAB Programming Fundamentals documentation.

Command Line Continuation

You can continue most statements to one or more additional lines by terminating each incomplete line with an ellipsis (...). Breaking down a statement into a number of lines can sometimes result in a clearer programming style.

sprintf ('Example %d shows a command coded on %d lines.\n', ...
          exampleNumber, ...
          numberOfLines)

Note that you cannot continue an incomplete string to another line.

disp 'This statement attempts to continue a string ...
      to another line, resulting in an error.'

For more information: See Entering Long Statements in the MATLAB Desktop Tools and Development Environment documentation.

Completing Commands Using the Tab Key

You can save some typing when entering commands by entering only the first few letters of the command, variable, property, etc. followed by the Tab key. Typing the second line below (with T representing Tab) yields the expanded, full command shown in the third line:

f = figure;
set(f, 'papTuT,'cT)                   % Type this line.
set(f, 'paperunits','centimeters')    % This is what you get.

If there are too many matches for the string you are trying to complete, you will get no response from the first Tab. Press Tab again to see all possible choices:

set(f, 'paTT
PaperOrientation   PaperPositionMode  PaperType     Parent
PaperPosition      PaperSize          PaperUnits

For more information: See Tab Completion in the Command Window in the MATLAB Desktop Tools and Development Environment documentation

Recalling Commands

Use any of the following methods to simplify recalling previous commands to the screen:

• To recall an earlier command to the screen, press the up arrow key one or more times, until you see the command you want. If you want to modify the recalled command, you can edit its text before pressing Enter or Return to execute it.
• To recall a specific command by name without having to scroll through your earlier commands one by one, type the starting letters of the command, followed by the up arrow key.
• Open the Command History window (View > Command History) to see all previous commands. Double-click the command you want to execute.

For more information: See Recalling Previous Lines and Command History Window in the MATLAB Desktop Tools and Development Environment documentation.

Clearing Commands

If you have typed a command that you then decide not to execute, you can clear it from the Command Window by pressing the Escape (Esc) key.

Suppressing Output to the Screen

To suppress output to the screen, end statements with a semicolon. This can be particularly useful when generating large matrices.

A = magic(100);     % Create matrix A, but do not display it.

Using the Help Browser
Open the Help browser from the MATLAB Command Window using
one of the following:


Click the question mark symbol in the toolbar.
Select Help > Product Help from the menu.
Type the word doc at the command prompt.

Some of the features of the Help browser are listed below. 
  


Feature
Description

Product Filter
Establish which products to find help on.
Contents
Look up topics in the Table of Contents.
Index
Look up help using the documentation Index.
Search
Search the documentation for one or more words.
Demos
See what demos are available; run selected demos.
Favorites
Save bookmarks for frequently used Help pages.



For more information:   See Finding Information with the Help Browser in the MATLAB Desktop Tools and Development Environment documentation.





Help on Functions from the Help Browser
To find help on any function from the Help browser, do either of the following:


Select the Contents tab of the Help browser, open the Contents entry
labeled MATLAB, and find the two subentries shown below. Use one of these to look up the function you want help on.


Functions — Categorical List
Functions — Alphabetical List


Type doc functionname at the command line.


Help on Functions from the Command Window
Several types of help on functions are available from the Command
Window:


To list all categories that you can request help on from the Command Window, just type help
To see a list of functions for one of these categories, along with a brief description of each function, type help category.
For example, help datafun
To get help on a particular function, type help functionname.
For example, help sortrows


Topical Help
In addition to the help on individual functions, you can get help on any of the following topics by typing help topicname at the command line.


Topic Name
Description

arith
Arithmetic operators
relop
Relational and logical operators
punct
Special character operators
slash
Arithmetic division operators
paren
Parentheses, braces, and bracket operators
precedence
Operator precedence
datatypes
MATLAB classes, their associated functions, and
operators that you can overload
lists
Comma separated lists
strings
Character strings
function_handle
Function handles and the @ operator
debug
Debugging functions
java
Using Sun Java from within the MATLAB software.
fileformats
A list of readable file formats
changeNotification
Microsoft Windows directory change notification







Paged Output
Before displaying a lengthy section of help text or code, put MATLAB into
its paged output mode by typing more on. This breaks up any ensuing display into pages for easier viewing. Turn off paged output with more off. Page through the displayed text using the space bar key. Or step through line by line using Enter or Return. Discontinue the display by pressing the Q key or Ctrl+C.





Writing Your Own Help
Start each program you write with a section of text providing help on how and when to use the function. If formatted properly, the MATLAB help function displays this text when you enter help functionname MATLAB considers the first group of consecutive lines immediately following the function definition line that begin with % to be the help section for the function. The first line without % as the left-most character ends the help.

For more information:   See Help Text in the MATLAB Desktop Tools and Development Environment documentation.





Help for Subfunctions and Private Functions
You can write help for subfunctions using the same rules that apply to main functions. To display the help for the subfunction mysubfun in file myfun.m, type help myfun>mysubfun To display the help for a private function, precede the function name with private/. To get help on private function myprivfun, type help private/myprivfun




Help for Methods and Overloaded Functions
You can write help text for object-oriented class methods implemented with M-files. Display help for the method by typing help classname/methodname where the file methodname.m resides in subdirectory @classname. For example, if you write a plot method for a class named polynom, (where the plot method is defined in the file @polynom/plot.m), you can display this help by typing help polynom/plot You can get help on overloaded MATLAB functions in the same way. To display the help text for the eq function as implemented in matlab/iofun/@serial, type help serial/eq.






M-File Structure
An M-File consists of the components shown here:

function [x, y] = myfun(a, b, c)   % Function definition line
% H1 line -- A one-line summary of the function's purpose.
% Help text -- One or more lines of help text that explain
%   how to use the function. This text is displayed when
%   the user types "help functionname".

% The Function body normally starts after the first blank line.
% Comments -- Description (for internal use) of what the
%   function does, what inputs are expected, what outputs
%   are generated. Typing "help functionname" does not display 
%   this text.

x = prod(a, b);         
% Start of Function code

For more information:   See Basic Parts of an M-File in the MATLAB Programming Fundamentals documentation.


Using Lowercase for Function Names
Function names appear in uppercase in MATLAB help text only to make the help easier to read. In practice, however, it is usually best to use lowercase when calling functions. For M-file functions, case requirements depend on the case sensitivity of the operating system you are using. As a rule, naming and calling functions using lowercase generally makes your M-files more portable from one operating system to another.





Getting a Function's Name and Path
To obtain the name of an M-file that is currently being executed,
use the following function in your M-file code.

mfilename
To include the path along with the M-file name, use

mfilename('fullpath')
For more information:   See
the mfilename function reference
page.





What M-Files Does a Function Use?
For a simple display of all M-files referenced by a particular function, follow the steps below:


Type clear functions to clear all functions from memory (see Note below).
Execute the function you want to check.
Note that the function arguments you choose to use in this step are important, since you can get different results when calling the same function with different arguments.
Type inmem to
display all M-Files that were used when the function ran. If you want to see what MEX-files were used as well, specify an additional output,
as shown here:

   [mfiles, mexfiles] = inmem



Note  


clear functions does not clear functions
locked by mlock. If you have
locked functions, (which you can check using inmem),
unlock them with munlock, and
then repeat step 1.



Dependent Functions, Built-Ins, Classes
For a much more detailed display of dependent function information, use the depfun function. In addition to M-files, depfun shows which built-ins and classes a particular function depends on.






Getting the Input and Output Arguments
Use nargin and nargout to determine the number of input
and output arguments in a particular function call. Use nargchk and nargoutchk to
verify that your function is called with the required number of input
and output arguments.

function [x, y] = myplot(a, b, c, d)
disp(nargchk(2, 4, nargin))           % Allow 2 to 4 inputs
disp(nargoutchk(0, 2, nargout))       % Allow 0 to 2 outputs

x = plot(a, b);
if nargin == 4
   y = myfun(c, d);
end

Variable Numbers of Arguments
You can call functions with fewer input and output arguments than you have specified in the function definition, but not more. If you want to call a function with a variable number of arguments, use the varargin and varargout function parameters in the function definition. This function returns the size vector and, optionally, individual dimensions:

function [s, varargout] = mysize(x)
nout = max(nargout, 1) - 1;
s = size(x);
for k = 1:nout
   varargout(k) = {s(k)};
end
Try calling it with

[s, rows, cols] = mysize(rand(4, 5))




String or Numeric Arguments
If you are passing only string arguments into a function, you can use MATLAB command syntax. All arguments entered in command syntax are interpreted as strings. strcmp string1 string1

ans =
     1
When passing numeric arguments, it is best to use function syntax unless you want the number passed as a string. The right-hand example below passes the number 75 as the string, '75'.

isnumeric(75)                   isnumeric 75
ans =                           ans =
    1                               0
For more information:   See Command vs. Function Syntax in the MATLAB Programming
Fundamentals documentation.


Passing Arguments in a Structure
Instead of requiring an additional argument for every value you want to pass in a function call, you can package them in a MATLAB structure and pass the structure. Make each input you want to pass a separate field in the structure argument, using descriptive names for the fields. Structures allow you to change the number, contents, or order of the arguments without having to modify the function. They can also be useful when you have a number of functions that need similar information.


Passing Arguments in a Cell Array
You can also group arguments into cell arrays. The disadvantage over structures is that you do not have field names to describe each variable. The advantage is that cell arrays are referenced by index, allowing you to loop through a cell array and access each argument passed in or out of the function.






Planning the Program
When planning how to write a program, take the problem you are trying to solve and break it down into a series of smaller, independent tasks. Implement each task as a separate function. Try to keep functions fairly short, each having a single purpose.





Using Pseudo-Code
You may find it helpful to write the initial draft of your program in a structured format using your own natural language. This pseudo-code is often easier to think through, review, and modify than using a formal programming language, yet it is easily translated into a programming language in the next stage of development.





Selecting the Right Data Structures
Look at what classes and data structures are available to you in MATLAB and determine which of those best fit your needs in storing and passing your data.

For more information: see Classes (Data Types) in the Programming Fundamentals documentation.


General Coding Practices
A few suggested programming practices:


Use descriptive function and variable names to make your code easier to understand.
Order subfunctions alphabetically in an M-file to make them easier to find.
Precede each subfunction with a block of help text describing what that subfunction does. This not only explains the subfunctions, but also helps to visually separate them.
Do not extend lines of code beyond the 80th column. Otherwise, it will be hard to read when you print it out.
Use full Handle Graphics property and value names. Abbreviated names are often allowed, but can make your code unreadable. They also could be incompatible in future releases of MATLAB.


Naming a Function Uniquely
To avoid choosing a name for a new function that might conflict with a name already in use, check for any occurrences of the name
using this command:

which -all functionname
For more information:   See the which function reference page.





The Importance of Comments
Be sure to document your programs well to make it easier for you or someone else to maintain them. Add comments generously, explaining each major section and any smaller segments of code that are not obvious. You can add a block of comments as shown here.

%---------------------------------------------
% This function computes the ... <and so on>
%---------------------------------------------
For more information:   See Comments in the MATLAB Programming Fundamentals documentation.





Coding in Steps
Do not try to write the entire program all at once. Write a portion of it, and then test that piece out. When you have that part working the way you want, then write the next piece, and so on. It's much easier to find programming errors in a small piece of code than in a large program.





Making Modifications in Steps
When making modifications to a working program, do not make widespread changes all at one time. It's better to make a few small changes, test and debug, make a few more changes, and so on. Tracking down a difficult bug in the small section that you've changed is much easier than trying to find it in a huge block of new code.


Functions with One Calling Function
If you have a function that is called by only one other function, put it in the same M-file as the calling function, making it a subfunction. For more information:   See Subfunctions in the MATLAB Programming Fundamentals documentation.





Testing the Final Program
One suggested practice for testing a new program is to step through the program in the MATLAB debugger while keeping a record of each line that gets executed on a printed copy of the program. Use different combinations of inputs until you have observed that every line of code is executed at least once.








The MATLAB Debug Functions
For a brief description of the main debug functions in MATLAB, type help debug

For more information:   See Debugging Process and Features in the MATLAB Desktop Tools and Development Environment documentation.





More Debug Functions
Other functions you may find useful in debugging are listed
below.


Function
Description

echo
Display function or script code as it executes.
disp
Display specified values or messages.
sprintf, 
fprintf
Display formatted data of different types.
whos
List variables in the workspace.
size
Show array dimensions.
keyboard
Interrupt program execution and allow input from keyboard.
return
Resume execution following a keyboard interruption.
warning
Display specified warning message.
MException
Access information on the cause of an error.
lastwarn
Return warning message that was last issued.







The MATLAB Graphical Debugger
Learn to use the MATLAB graphical debugger. You can view the function and its calling functions as you debug, set and clear breakpoints, single-step through the program, step into or over called functions, control visibility into all workspaces, and find and replace strings in your files. Start out by opening the file you want to debug using File > Open or the open function. Use the debugging functions available on the toolbar and pull-down menus to set breakpoints, run or step through the program, and examine variables.

For more information:   See Debugging Process and Features in the MATLAB Desktop Tools and Development Environment documentation.





A Quick Way to Examine Variables
To see the value of a variable from the Editor/Debugger window, hold the mouse cursor over the variable name for a second or two. You will see the value of the selected variable displayed.


Setting Breakpoints from the Command Line
You can set breakpoints with dbstop in any of the following ways:


Break at a specific M-file line number.
Break at the beginning of a specific subfunction.
Break at the first executable line in an M-file.
Break when a warning, or error, is generated.
Break if any infinite or NaN values
are encountered.

For more information:   See Setting Breakpoints in the MATLAB Desktop Tools and Development Environment documentation. 


Finding Line Numbers to Set Breakpoints
When debugging from the command line, a quick way to find line numbers for setting breakpoints is to use dbtype. The dbtype function displays all or part of an
M-file, also numbering each line. To display delaunay.m, use dbtype delaunay

To display only lines 35 through 41, use dbtype delaunay 35:41


Stopping Execution on an Error or Warning
Use dbstop if error to stop program execution on any error and enter debug mode. Use dbstop if warning to stop execution on any warning and enter debug mode.

For more information:   See Debugging Process and Features in the MATLAB Desktop Tools and Development Environment documentation.


Locating an Error from the Error Message
Click on the underlined text in an error message, and MATLAB opens the M-file being executed in its editor and places the cursor at the point of error.

For more information:   See Finding Errors, Debugging, and Correcting M-Files in the MATLAB Desktop Tools and Development Environment documentation.





Using Warnings to Help Debug
You can detect erroneous or unexpected behavior in your programs by inserting warning messages that MATLAB will display under the conditions you specify. See the section on Warning Control in the MATLAB Programming Fundamentals documentation to find out how to selectively enable warnings.

For more information:   See the warning function reference page.


Making Code Execution Visible

An easy way to see the end result of a particular line of codeis to edit the program and temporarily remove the terminating semicolon from that line. Then, run your program and the evaluation of that statement is displayed on the screen.
For more information:   See Finding Errors, Debugging, and Correcting M-Files in the MATLAB Desktop Tools and Development Environment documentation.





Debugging Scripts
Scripts store their variables in a workspace that is shared with the caller of the script. So, when you debug a script from the command line, the script uses variables from the base workspace. To avoid errors caused by workspace sharing, type clear all before starting to debug your script to clear the base workspace.






Rules for Variable Names Although variable names can be of any length, MATLAB uses only the first N characters of the name, (where N is the number returned by the function namelengthmax), and ignores the rest. Hence, it is important to make each variable name unique in the first N characters to enable MATLAB to distinguish variables. Also note that variable names are case sensitive.
N = namelengthmax
N =
    63
For more information:   See Naming Variables in the MATLAB Programming Fundamentals documentation.


Making Sure Variable Names Are Valid
Before using a new variable name, you can check to see if it is valid with the isvarname function.
Note that isvarname does not consider names longer than namelengthmax characters to be valid.

For example, the following name cannot be used for a variable since it begins with a number.

isvarname 8thColumn
ans =
     0
For more information:   See Naming Variables in the MATLAB Programming Fundamentals documentation.


Do Not Use Function Names for Variables
When naming a variable, make sure you are not using a name that is already used as a function name. If you do define a variable with a function name, you will not be able to call that function until you clear the variable from memory. (If it's a MATLAB built-in function, then you will still be able to call that function but you must do so using builtin.) To test whether a proposed variable name is already used as a function name, use which -all name For more information:   See Potential Conflict with Function Names in the MATLAB Programming Fundamentals documentation.


Checking for Reserved Keywords
MATLAB reserves certain keywords for its own use and does not allow you to override them. Attempts to use these words may result in any one of a number of error messages, some of which are shown here: Error: Expected a variable, function, or constant, found "=". Error: "End of Input" expected, "case" found. Error: Missing operator, comma, or semicolon. Error: "identifier" expected, "=" found. Use the iskeyword function with no input arguments to list all reserved words.


Avoid Using i and j for Variables
MATLAB uses the characters i and j to represent imaginary units. Avoid using i and j for variable names if you intend to use them in complex arithmetic. If you want to create a complex number without using i and j, you can use the complex function.





Avoid Overwriting Variables in Scripts
MATLAB scripts store their variables in a workspace that is shared with the caller of the script. When called from the command line, they share the base workspace. When called from a function,  they share that function's workspace. If you run a script that alters a variable that already exists in the caller's workspace, that variable is overwritten by the script. For more information:   See M-File Scripts in the MATLAB Programming

Fundamentals documentation.





Persistent Variables
To get the equivalent of a static variable in MATLAB, use persistent. When you declare a variable to be persistent within a function, its value is retained in memory between calls to that function. Unlike global variables, persistent variables are known only to the function in which they are declared. For more information:   See Persistent Variables in the MATLAB Programming Fundamentals documentation.





Protecting Persistent Variables
You can inadvertently clear persistent variables from memory by either modifying the function in which the variables are defined, or by clearing the function with one of the following commands: clear all clear functions Locking the M-file in memory with mlock prevents any persistent variables defined in the file from being reinitialized.





Global Variables
Use global variables sparingly. The global workspace is shared by all of your functions and also by your interactive MATLAB session. The more global variables you use, the greater the chances of unintentionally reusing a variable name, thus leaving yourself open to having those variables change in value unexpectedly. This can be a difficult bug to track down.

For more information:   See Global Variables in the MATLAB Programming Fundamentals documentation.






Creating Strings with Concatenation
Strings are often created by concatenating smaller elements together (e.g., strings, values, etc.). Two common methods of concatenating are to use the MATLAB concatenation operator ([]) or the sprintf function. The second and third line below illustrate both of these methods. Both lines give the same result:

numChars = 28;
s = ['There are ' int2str(numChars) ' characters here']
s = sprintf('There are %d characters here', numChars)
For more information:   See Creating Character Arrays and Converting from Numeric to String in the MATLAB Programming Fundamentals documentation.





Comparing Methods of Concatenation
When building strings with concatenation, sprintf is often preferable to [] because


It is easier to read, especially when forming complicated expressions
It gives you more control over the output format
It often executes more quickly

You can also concatenate using the strcat function, However, for simple concatenations, sprintf and [] are faster.





Store Arrays of Strings in a Cell Array
It is usually best to store an array of strings in a cell array instead of a character array, especially if the strings are of different lengths. Strings in a character array must be of equal length, which often requires padding the strings with blanks. This is not necessary when using a cell array of strings that has no such requirement.

The cellRecord below does not require padding the strings with spaces:

cellRecord = {'Allison Jones'; 'Development'; 'Phoenix'};
For more information:   See Cell Arrays of Strings in the MATLAB Programming Fundamentals documentation.





Converting Between Strings and Cell Arrays
You can convert between standard character arrays and cell arrays of strings using the cellstr and char functions:

charRecord = ['Allison Jones'; 'Development  '; ... 
              'Phoenix      '];
cellRecord = cellstr(charRecord);

Also, a number of the MATLAB string operations can be used with either character arrays, or cell arrays, or both:

cellRecord2 = {'Brian Lewis'; 'Development'; 'Albuquerque'};
strcmp(charRecord, cellRecord2)
ans =
     0
     1
     0
For more information:   See Converting to a Cell Array of Strings and String Comparisons in the MATLAB Programming Fundamentals documentation.


Search and Replace Using Regular Expressions
Using regular expressions in MATLAB offers a very versatile way of searching for and replacing characters or phrases within a string. See the help on these functions for more information.   


Function
Description

regexp
Match regular expression.
regexpi
Match regular expression, ignoring case.
regexprep
Replace string using regular  expression.



For more information:   See Regular Expressions in the MATLAB Programming Fundamentals documentation.






Find Alternatives to Using eval
While the eval function can provide a convenient solution to certain programming challenges, it is best to limit its use. The main reason is that code that uses eval is often difficult to read and hard to debug. A second reason is that eval statements cannot always be translated into C or C++ code by the MATLAB Compiler. If you are evaluating a function, it is more efficient to use feval than eval. The feval function is made specifically for this purpose and is optimized to provide better performance.

For more information:   See MATLAB Technical Note 1103, "What Is the EVAL Function, When Should I Use It, and How Can I Avoid It?" at URL http://www.mathworks.com/support/tech-notes/1100/1103.html.


Assigning to a Series of Variables
One common pattern for creating variables is to use a variable name suffixed with a number (e.g., phase1, phase2, phase3, etc.). We recommend using a cell array to build this type of variable name series, as it makes code more readable and executes more quickly than some other methods. For example:

for k = 1:800
   phase{k} = expression;
end

Short-Circuit Logical Operators
MATLAB has logical AND and OR operators (&& and ||) that enable you to partially evaluate, or short-circuit, logical expressions. Short-circuit operators are useful when you want to evaluate a statement only when certain conditions are satisfied. In this example, MATLAB does not execute the function myfun unless its M-file exists on the current path.

comp = (exist('myfun.m') == 2) && (myfun(x) >= y) 
For more information:   See Short-Circuit Operators in the MATLAB Programming Fundamentals documentation.




Changing the Counter Variable within a for Loop
You cannot change the value of the loop counter variable (e.g., the variable k in the example below) in the body of a for loop. For example, this loop executes just 10 times, even though k is
set back to 1 on each iteration.

for k = 1:10
   fprintf('Pass %d\n', k)
   k = 1;
end
Although MATLAB does allow you to use a variable of the same name as the loop counter within a loop, this is not a recommended
practice.






Precedence Rules
When MATLAB is given a name to interpret, it determines its usage by checking the name against each of the entities listed below, and in the order shown:


Variable
Subfunction
Private function
Class constructor
Overloaded method
M-file in the current directory
M-file on the path, or MATLAB built-in function

If you have two or more M-files on the path that have the same name, MATLAB selects the function that has its M-file in the directory closest to the beginning of the path string.

For more information:   See Function Precedence Order in the MATLAB Programming
Fundamentals documentation.


File Precedence
If you refer to a file by its filename only (leaving out the file extension), and there is more than one file of this name in the directory, MATLAB selects the file to use according to the following precedence:


MEX-file
MDL-file (Simulink model)
P-Code file
M-file

For more information:   See Multiple Implementation Types in the MATLAB Programming Fundamentals documentation.


Adding a Directory to the Search Path
To add a directory to the search path, use either of the following:


At the toolbar, select File > Set Path.
At the command line, use the addpath function.

You can also add a directory and all of its subdirectories in one operation by either of these means. To do this from the command line, use genpath together with addpath. The online help for the genpath function shows how to do this. This example adds /control and all of its subdirectories to the MATLAB path: addpath(genpath('K:/toolbox/control'))

For more information:   See Search Path in the MATLAB Desktop Tools and Development Environment documentation.


Handles to Functions Not on the Path
You cannot create function handles to functions that are not on the MATLAB path. But you can achieve essentially the same thing by creating the handles through a script file placed in the same off-path directory as the functions. If you then run the script, using run path/script, you will have created the handles that you need.

For example,


Create a script in this off-path directory that constructs function handles and assigns them to variables. That script might look something like this:

File E:/testdir/createFhandles.m
   fhset = @setItems
   fhsort = @sortItems
   fhdel = @deleteItem

Run the script from your current directory to create the function handles:

run E:/testdir/createFhandles

You can now execute one of the functions by means of its handle.

fhset(item, value)



Making Toolbox File Changes Visible to MATLAB
Unlike functions in user-supplied directories, M-files (and MEX-files) in the matlabroot/toolbox directories are not time-stamp checked, so MATLAB does not automatically see changes to them. If you modify one of these files, and then rerun it, you may find that the behavior does not reflect the changes that you made. This is most likely because MATLAB is still using the previously loaded version of the file. To force MATLAB to reload a function from disk, you need to explicitly clear the function from memory using clear functionname. Note that there are rare cases where clear will not have the desired effect, (for example, if the file is locked, or if it is a class constructor and objects of the given class exist in memory).

Similarly, MATLAB does not automatically detect the presence of new files in matlabroot/toolbox directories. If you add (or remove) files from these directories, use rehash toolbox to force MATLAB to see your changes. Note that if you use the MATLAB Editor to create files, these steps are unnecessary, as the Editor automatically informs MATLAB of such changes.


Making Nontoolbox File Changes Visible to MATLAB
For M-files outside of the toolbox directories, MATLAB sees the changes made to these files by comparing timestamps and reloads any file that has changed the next time you execute the corresponding function. If MATLAB does not see the changes you make to one of these files, try clearing the old copy of the function from memory using clear functionname. You can verify that MATLAB has cleared the function using inmem to list all functions currently loaded into memory.





Change Notification on Windows
If MATLAB, running on Windows, is unable to see new files or changes you have made to an existing file, the problem may be related to operating system change notification handles.

Type the following for more information:

help changeNotification
help changeNotificationAdvanced





Program Control



Using break, continue, and return

Using switch Versus if

MATLAB case Evaluates Strings

Multiple Conditions in a case Statement

Implicit Break in switch-case

Variable Scope in a switch

Catching Errors with try-catch

Nested try-catch Blocks

Forcing an Early Return from a Function


Using break, continue, and return
It's easy to confuse the break, continue, and return functions as they are similar in some ways. Make sure you use these functions appropriately.


Function
Where
to Use It
Description

break
for or while loops
Exits the loop in which it appears. In nested loops,
control passes to the next outer loop.
continue
for or while loops
Skips any remaining statements in the current loop. Control
passes to next iteration of the same loop.
return
Anywhere
Immediately exits the function in which it appears. Control
passes to the caller of the function.






Using switch Versus if
It is possible, but usually not advantageous, to implement switch-case statements
using if-elseif instead. See pros and cons in the table.


switch-case Statements
if-elseif
Statements

Easier to read.
Can be difficult to read.
Can compare strings of different lengths.
You need strcmp to
compare strings of different lengths.
Test for equality only.
Test for equality or inequality.







MATLAB case Evaluates Strings
A useful difference between switch-case statements in MATLAB and C is that you can specify string values in MATLAB case statements, which you cannot do in C.

switch(method)
   case 'linear'
      disp('Method is linear')
   case 'cubic'
      disp('Method is cubic')
end




Multiple Conditions in a case Statement
You can test against more than one condition with switch. The first case below tests for either a linear or bilinear method by using a cell array in the case statement.

switch(method)
   case {'linear', 'bilinear'}
      disp('Method is linear or bilinear')
   case (<and so on>)
end


 Back to Top

Implicit Break in switch-case
In C, if you do not end each case with a break statement, code execution falls through to the following case. In MATLAB, case statements do not fall through;
only one case may execute. Using break within a case statement is not only unnecessary, it is also invalid and generates a warning. In this example, if result is 52, only the first disp statement

executes, even though the second is also a valid match:

switch(result)
   case 52
      disp('result is 52')
   case {52, 78}
      disp('result is 52 or 78')
end

 Back to Top

Variable Scope in a switch
Since MATLAB executes only one case of any switch statement, variables defined within one case are not known in the other cases of that switch statement. The same holds true for if-elseif statements. In these examples, you get an error when choice equals 2, because x is undefined.

  -- SWITCH-CASE --                    -- IF-ELSEIF --
switch choice
   case 1                          if choice == 1
      x = -pi:0.01:pi;                x = -pi:0.01:pi;
   case 2                          elseif choice == 2
      plot(x, sin(x));                plot(x, sin(x));
end                                end




Catching Errors with try-catch
When you have statements in your code that could possibly generate unwanted results, put those statements into a try-catch block that will catch any errors and handle them appropriately.

The example below shows a try-catch block within a function that multiplies two matrices. If a statement in the try segment of the block fails, control passes
to the catch segment. In this case, the catch statements check the error message that was issued (returned in MException object, err) and respond appropriately:

try
   X = A * B
catch err
   errmsg = err.message;
   if(strfind(errmsg, 'Inner matrix dimensions'))
      disp('** Wrong dimensions for matrix multiply')
end
For more information:   See The try-catch Statement in the MATLAB Programming Fundamentals documentation.


Nested try-catch Blocks
You can also nest try-catch blocks, as shown here. You can use this to attempt to recover from an error caught in the first try section: try

   statement1                    % Try to execute statement1
catch
   try
      statement2                 % Attempt to recover from error
   catch
      disp 'Operation failed'    % Handle the error
   end
end




Forcing an Early Return from a Function
To force an early return from a function, place a return statement in the function at the point where you want to exit. For example, 

if <done>
   return
end