# MATLAB Glossary

## Punctuation

A single MATLAB command typically has the form:

```        result = function ( value )
```
where function represents the name of some function, value represents the input to the function, and result represents the output of the function.

In the above example, spaces may be inserted at will around any of the "tokens", or the line might be squeezed tight. Spaces could not be inserted between individual letters of the names, of course.

A function may have no input arguments, just one, or several. If it has no input arguments, the parentheses are dropped entirely. If it has multiple input arguments, then commas are used to separate them.

```
result = function
result = function ( arg1 )
result = function ( arg1, arg2, arg3 )
```

A function may have no output arguments, just one, or several. If it has no output arguments, then the equals sign is not used. If it has more than one output argument, they are grouped with square brackets.

```
function ( a, b, c )
x         = function ( a, b, c )
[ x, y, z ] = function ( a, b, c )
```

Most functions return one or more output arguments. The value of these output arguments will be printed automatically unless the command line terminates with a semicolon. The first command will print, and the second will not:

```
x         = function ( a, b, c )
x         = function ( a, b, c );
```

A series of short commands may be placed on a single line of text as long as they are separated by commas. The output of every command will be printed unless the string of commands is terminated by a semicolon:

```
y = f ( x ), z = f ( w ), q = f ( p );
```

If a command is too long to fit on a single line, it may be extended over several lines by ending each partial line with an ellipsis:

```
sum = a + b + c + d + ...
e + f + g + h + ...
i + j
```

There is a small inconsistency in this rule. If you are entering a matrix, then you are allowed to enter one row per line while skipping the ellipsis (and the semicolon that would normally indicate the end of a row). Thus, the following "economical" command:

```
A = [ 1  2  3
4  5  6 ]
```
is equivalent to:
```
A = [ ...
1, 2, 3; ...
4, 5, 6 ]
```

## Named Constants

MATLAB includes several constants that can be invoked by name:
Name Meaning
eps The machine precision number
Inf Infinity
i The square root of -1
j The square root of -1
NaN "Not a Number"
pi 3.14159265...
realmaxThe largest real number;
realminThe smallest positive real number;

Since i and j are compulsively used by programmers as loop indices, the fact that MATLAB expects them to represent the imaginary unit is a classic bad idea that will automatically generate more errors than we need in this world.

## Arithmetic Operators

The basic arithmetic operators used in MATLAB include:
SymbolMeaning
- Subtraction
* Matrix multiplication
.* Elementwise multiplication
/ Matrix "division"
./ Elementwise division
\ Matrix "division": A\b means A-1*b
.\ Elementwise division
^ Matrix exponentiation
.^ Elementwise exponentiation
' Matrix conjugate transpose
.' Matrix unconjugated transpose

## Arithmetic Functions

The basic arithmetic functions available in MATLAB include:
Name Meaning
abs absolute value
acos inverse cosine
angle the angle or argument of a complex number
asin inverse sine
atan inverse tangent
atan2 inverse tangent of (y,x)
ceil round to integer, towards +infinity
conj the conjugate of a complex number
cos cosine
cosh hyperbolic cosine
cot cotangent
csc cosecant
exp exponential
fix round to integer, towards 0
floor round to integer, towards -infinity
imag the imaginary part of a complex number
log natural logarithm
log2 logarithm base 2
log10 logarithm base 10
mod remainder after division, mod(x,y) has same sign as x
real the real part of a complex number
rem remainder after division, rem(x,y) has same sign as y
round round to nearest integer
sec secant
sign the sign function
sin sine
sinh hyperbolic sine
sqrt square root
tan tangent
tanh hyperbolic tangent

## Logical Values

MATLAB does not have a special logical data type. However, functions, expressions and variables with a "logical" value, which actually have a numeric value, use the following convention:
Numeric ValueMeaning
0 False
1 True
nonzeroTrue
Note that, while any nonzero value will behave like a logical "true", all functions and expressions that intend to return a logical value of true should return the preferred numeric value of 1.

## Logical Operators

The logical operators used in MATLAB include:
SymbolMeaning
& logical AND
| logical OR
~ logical complement or NOT
xor Exclusive OR
These operators are applied to a logical condition, which is true or false, or a numeric value, in which case nonzero is true, and zero is false.

## Logical Functions

The basic logical functions include:
SymbolMeaning
> greater than
>= greater than or equal to
< less than
<= less than or equal to
== equal to
~= not equal to
Each of these functions can be used to compare two objects, and returns a value that is FALSE (0) or TRUE (1). If the objects are vectors or matrices, then the value returned will have the same shape (a vector or matrix or 0's and 1's).

Other logical functions include:
SymbolMeaning
all ( X ) All entries of X are nonzero;
any ( X ) Any entry of X is nonzero
Each of these functions can be used query a vector or matrix of values. If X is a vector, then the value returned is a scalar. If X is a matrix, then the value returned is a row vector, and each entry of the result is the value of the query for the corresponding column of X. Thus, if V is a vector, any(V) is the single value 1 (TRUE) if any entry of V is nonzero. If A is an m by n matrix, then all(A) is a row vector of length n, and entry J is 1 (TRUE) if column J of the matrix is entirely nonzero.

## Vector Operators

Certain operations can be applied to a vector:
SymbolMeaning
v+wthe vector of sums of entries of v and w
v*w'the scalar product of row vectors v and w
v'*wthe outer product of row vectors v and w
v.*wthe vector of pairwise products of entries of v and w

## Vector Functions

Certain functions can be applied to a vector:
SymbolMeaning
v'the transpose of v
find(v)returns the indices of nonzero (or TRUE) entries of v
max(v)the maximum entry of v
min(v)the minimum entry of v
prod(v)the product of the entries of v
sum(v)the sum of the entries of v

## Matrix Operators

Certain operations can be applied to a matrix:
SymbolMeaning
A'the transpose of A
A+Bthe elementwise sum of A and B
A*Bthe (standard) product of A and B
A.*Bthe elementwise product of A and B
A^2the square of A
A.^2the elementwise square of A

## Matrix Functions

Certain functions can be applied to a matrix:
SymbolMeaning
det(A)the determinant of (the square matrix) A
find(A)returns the row and column indices of nonzero (or TRUE) entries of A
inv(A)the inverse of (the square matrix) A
max(A)a row vector containing the maximum of each column
max(max(A))the maximum entry of A
min(A)a row vector containing the minimum of each column
min(min(A))the minimum entry of A

## Variables

A MATLAB function typically has three kinds of variables,

• input variables, which appear in the list of input arguments;
• output variables, which appear in the list of output arguments;
• local variables, which do not appear in either input or output arguments.

By default, local variables do not exist before the function is invoked. Any value they have must be assigned during the execution of the function, and that value is lost when the function is exited.

In some cases, it may be desirable to change the behavior of a local variable, so that, for instance, it has a value that "persists" between calls of the function, or it has a value that can be "seen" by some other routines, or even altered by other routines.

### Persistent Variables

In FORTRAN, some variables may be declared with the "save" attribute. In C, the corresponding idea is called a "static" variable. In both languages, the intent is that once certain variables have been brought into existence by calling a routine, the memory associated with those variables is kept throughout the execution of the entire program. When the function that created these variables is exited, the variables stay around; if the function is invoked again, it recovers the variables with their current values.

To achieve this behavior in MATLAB, a variable must be declared "persistent", as in

```
persistent x
persistent y, z
```

Here is an example program that uses a persistent variable. On each call, it returns the sum of every argument with which it has been invoked:

```
function total = grudge ( flag, x )

persistent my_sum;

if ( flag )
my_sum = 0;
else
my_sum = my_sum + x;
end

total = my_sum;
```
Presumably, a user of the routine would be told that the first call to my_sum should be with flag=1, so that my_sum can be initialized. Thereafter, the routine can be called repeatedly with flag=0, and each time the input argument x will be added to the current running total.

In some cases, it may be desired not to burden the user with having to pass in a flag to initialize the variables. It's not something users are good at, after all. Instead, the model might be that the internal variables will "know" whether they have been set up yet or not. A reasonable way to do this is to ask for the "size" of the variable. If a value has never been assigned to it, then its size will be zero.

```
function total = reverse ( fred )

persistent flip;

if ( size ( flip ) == 0 )
flip = 1;
end

total = fred + flip;

flip = 1 - flip;
```
Here, the intent is that flip is 1 on calls 1, 3, 5, ..., and 0 on calls 2, 4, 6, and so on. But no external information is needed to properly initialize the value.

### Global Variables

In FORTRAN77, a device called a COMMON block allowed different routines to access the same variables, without requiring transmission through the argument list. In FORTRAN90, this can be done using MODULES. In C, data can be shared among routines that are in the same source code file by declaring the data in the beginning of the file, "outside" of the text of any particular routine.

In each case, the desire is that the memory associated with certain variables be easily accessible by name. The corresponding feature in MATLAB is a "global" variable. If a variable is declared global, then its value is shared among all routines that invoke the same declaration. The value of the global variable persists throughout the execution of the program.

Thus, in order for the functions bob.m and carol.m to share the value of the variable ted, they would both need to include the declaration

```
global ted
```
Then a single memory location ted is created and shared by the two programs. Changes to ted by one routine will be visible to the other routine.

## Control Structures

Control structures are used to control the execution of statements. The common control structures include for, if and while.

### The FOR Loop

A simple example of a FOR loop:

```
sum = 0;
for ( i = 1 : 5 )
sum = sum + i^2;
end
```
In this case, the loop is executed with i having the values 1, 2, 3, 4, and 5.

To specify a loop increment that is not 1, use notation like the following:

```
for ( i = 1 : 10 : 3 )
```
In this case, the loop is executed with i having the values 1, 4, 7, 10. Similarly, a decreasing loop index can be achieved by the form:
```
for ( i = 10 : 1 : -3 )
```
which happens to go through the same values, but in reverse order.

In some cases, you may want to skip the rest of a particular cycle of the loop, without actually terminating the loop. This can be done using the continue statement:

```
sum = 0;
for ( i = 1 : 10 )
if ( x(i) == 0 )
continue
end
sum = sum + 1 / x(i);
end
```

On the other hand, there are cases (such as a search) where you may suddenly want to terminate the loop. This can be done using the break statement:

```
location = 0;
for ( i = 1 : 10 )
if ( x(i) == 17 )
location = i;
break;
end
end
```

### The IF Statement

A simple example of an IF statement:

```
if ( mod ( n, 2 ) == 0 )
n = n / 2;
end
```

A more elaborate example of an IF/ELSE statement:

```
if ( mod ( n, 2 ) == 0 )
n = n / 2;
else
n = 3 * n + 1;
end
```

A more elaborate example of an IF/ELSEIF/ELSE statement:

```
if ( mod ( n, 3 ) == 0 )
n = n / 3;
elseif ( mod ( n, 3 ) == 1 )
n = 4 * n + 1;
else
n = 4 * n + 2;
end
```

Note that elseif is not the same as else if! The elseif command stays at the level of the opening if, and considers an alternate possibility:

```
if ( x < 0 )
there is no square root
elseif ( x == 0 )
the square root is zero
end
```
The else if command is really two commands, an else at the level of the opening if, and a new if which takes us down a level. Note, in particular, that there will have to be at least two end statements following!
```
if ( x < 0 )
there is no square root
else if ( x == 0 )
the square root is zero
end
end
```
which is equivalent to:
```
if ( x < 0 )
there is no square root
else
if ( x == 0 )
the square root is zero
end
end
```
The problem is that elseif and else if look identical to the programmer, but not to MATLAB!

### The WHILE Loop

A simple example of a WHILE loop:

```
n = 98;
log_base_2 = 0;
while ( n > 1 )
n = n / 2;
log_base_2 = log_base_2 + 1;
end
```

To make a "WHILE forever" loop, use a nonzero value, typically 1, as the "condition" to be checked:

```
n = 98;
log_base_2 = 0;
while ( 1 )
n = n / 2;
log_base_2 = log_base_2 + 1;
if ( n == 0 )
break;
end
end
```
A break statement allows you to exit the while loop. A continue statement allows you to skip the remainder of the while loop, and begin the next iteration.

## Input

### The input command

The simplest input requirement occurs when you're running a Matlab script interactively, and you want to ask the user to enter a number that specifies what to do next, such as how many iterations to perform, or what error tolerance to impose. To do this, one can use the input function, which takes a prompt string as its input argument, and returns as its value the number (or vector or matrix) that the user typed in.

```        iter_max = input ( 'Enter the maximum number of iterations.' );
```

In some cases, it is convenient or even necessary that information in a file be read into MATLAB. (In fact, it is also possible for MATLAB to write out information into a file, which can be read back in at a later time, using the save command...). In the simplest case, the user has prepared an ASCII text file containing one number, or one line of text containing several numbers, or several lines of text each containing the same number of values. Assuming the file is called fred.txt, say, then the user can have MATLAB read the values in the file and assign them to a variable with a command like

```        array = load ( 'fred.txt' )
```

### C-style input commands

MATLAB also allows the user to open an existing file with fopen, extract information using fread, fscanf, fgetl and fgets, and then close the file with fclose. The form and use of these commands is quite similar to their C ancestors.

## Output

### The Default Printing of Results

Most MATLAB statements are assignments or computations that have a result. By default, this result is printed once it's computed. This means that simple MATLAB codes don't need any fancy output statements. Executing the statements

```         a = 4
b = sqrt ( a )
c = 1 / ( a + b )
```
will result in the printout of the values 4, 2, and 1/6. In fact, if you want to check the value of a variable, all you have to do is enter its name:
```        d
```
will cause the value of d to be displayed.

This default printing operation always includes the name of the variable in the output, as well as an "=" sign and possibly one or two blank lines. If you simply want to see the value of a variable or expression, you can use the disp function to do so:

```        disp ( 4 )
disp ( sqrt ( a ) )
disp ( 1 / ( a + b ) )
disp ( 'Hi there, everyone!' )
```
These commands will, in each case, print out the unlabeled value.

While this default printing can be handy, sometimes you don't want to see it, especially inside of functions or iterative calculations. Any line that produces a result can be "silenced" by terminating it with a semicolon. Thus, the following commands will not produce any printed output:

```        a = 5;
b = mod ( 32, 7 );
c = cos ( pi / 5 ) + sin ( pi / 5 );
```
It's not so easy to shut up the disp command. Even if you type
```        disp ( 4 );
```
the disp command will still print out the value.

### Using FPRINTF for formatted output

One way to control the style of output from MATLAB is to use the fprintf command. This command has the logical form

```        fprintf ( unit, string, arg1, arg2, ... )
```
To print directly to the screen, the value of unit should be 1. The string contains the form of the output line, except that positions where a variable's value is to appear are marked by a placeholder that begins with a percent sign, and a new line, or carriage return, is indicated by the string '\n'. The corresponding variables themselves are then listed as arg1 and so on.

For instance, you might print

```        fprintf ( 1, 'The results follow:\n' )
fprintf ( 1, '  X + Y = %f\n', x + y )
fprintf ( 1, '  Caesar''s first name was %s.\n', pronomen );
fprintf ( 1, '  Today is %d and I am %d years old.\n', year, age );
```

For additional control, you may specify, for instance, the number of spaces to be used in printing out the variable:

```        fprintf ( 1, 'The results follow:\n' )
fprintf ( 1, '  X + Y = %12f\n', x + y )
fprintf ( 1, '  Caesar''s first name was %10s.\n', pronomen );
fprintf ( 1, '  Today is %4d and I am %2d years old.\n', year, age );
```

Integers are normally printed with the d marker, but "very large" integers will not be displayed in decimal form, but rather in scientific notation, no matter how hard you try.

### How do I print a complex number?

For a program in which complex arithmetic is used for all arithmetic data types, the proper printing of a complex number through FPRINTF can be surprisingly difficult. Unless you redefine it, the name i will signify the imaginary unit, so you can use it to form complex expressions. I started with the following statements:

```        x = 1 + 2 * i
fprintf ( 1, 'X = %f\n', x );
```
but what prints out is simply "1". Even if you take a guess at the fix and try
```        fprintf ( 1, 'X = %f  %f\n', x );
```
you get nothing but "1". I tried other format specifiers, but got nowhere. As far as I could tell, there is no appropriate format string that will cause a complex number to be printed properly.

A correspondent, Alan Weiss, has let me know that the appropriate way to handle this problem is to use the Matlab command num2str to convert the complex number to a string, and then print it as as string:

```        x = 1 + 2 * i
fprintf ( 1, 'X = %s\n', num2str ( x ) );
```
and this, indeed, works.

Before finding out that useful piece of information, I assumed that I had to get the result I wanted using only the knowledge I had. Since the imaginary part of a complex number exists, and we can access it with the imag function, we could get a printout doing this:

```        x = 1 + 2 * i
fprintf ( 1, 'X = %f  %f\n', real ( x ), imag ( x ) );
```

Once you see that that actually works, it's time to celebrate by throwing in the plus sign and the "i":

```        x = 1 + 2 i
fprintf ( 1, 'X = %f + %f i\n', real ( x ), imag ( x ) );
```
and now you can decide whether you want to properly handle the case where the imaginary part is negative. (You'd like to avoid the ugly expression "1 + -2 i", for instance.) Obviously, it's time to give up and use the num2str function unless you have a really good reason not to!

## The CLEAR Command

MATLAB "remembers" all the variables that it encounters. Sometimes this can be a disadvantage. During a lengthy session, or in a situation where a number of independent functions are invoked, it may be the case that the pre-existence of a given variable causes a normally well-behaved function to fail. For instance, you might think that the following statements are essentially the same:

```        x = zeros(1,5);
x(1:5) = 0;
```

But in the first case, any previous meaning that x had is discarded, and x is guaranteed to be a 1 by 5 vector of 0's. In the second case, we'll get an error message if a variable called x already exists, but cannot legally be addressed as a vector. Moreover, if a vector x does already exist, then its entries after entry 5 are still around, which may cause some nasty surprises.

This is only one reason why it might be nice to "clear out" one, several, or all old variables at certain points in a script, or an interactive session. Thus, typing

```        clear x
```
discards any variable called x. Typing
```        clear x y z
```
clears three variables out at once, and typing
```        clear
```
```        exit