# MATLAB

## Introduction

MATLAB stands for Matrix Laboratory. According to The Mathworks, its producer, it is a "technical computing environment". We will take the more mundane view that it is a programming language.

This section covers much of the language, but by no means all. We aspire to at the least to promote a reasonable proficiency in reading procedures that we will write in the language but choose to address this material to those who wish to use our procedures and write their own programs.

## MATLAB Versions

Versions of MATLAB are available for almost all major computing platforms. Our material was produced and tested on the version designed for the Microsoft Windows environment. The vast majority of it should work with other versions, but no guarantees can be offered.

Of particular interest are the Student Versions of MATLAB. Prices are generally below \$100. These systems include most of the features of the language, but no matrix can have more than 8,192 elements, with either the number of rows or columns limited to 32. For many applications this proves to be of no consequence. At the very least, one can use a student version to experiment with the language.

The Student Editions are sold as books with disks enclosed. They are published by Prentice-Hall and can be ordered through bookstores.

In addition to the MATLAB system itself, Mathworks offers sets of Toolboxes, containing MATLAB functions for solving a number of important types of problems. Of particular interest to us is the optimization toolbox, which will be discussed in a later section.

## Matrices as Fundamental Objects

MATLAB is one of a few languages in which each variable is a matrix (broadly construed) and "knows" how big it is. Moreover, the fundamental operators (e.g. addition, multiplication) are programmed to deal with matrices when required. And the MATLAB environment handles much of the bothersome housekeeping that makes all this possible. Since so many of the procedures required for Macro-Investment Analysis involve matrices, MATLAB proves to be an extremely efficient language for both communication and implementation.

## Matrix Operations

Consider the following MATLAB expression:

```	C = A + B
```

If both A and B are scalars (1 by 1 matrices), C will be a scalar equal to their sum. If A and B are row vectors of identical length, C will be a row vector of the same length, with each element equal to the sum of the corresponding elements of A and B. Finally, if A and B are, say, {3*4} matrices, so will C, with each element equal to the sum of the corresponding elements of A and B.

In short the symbol "+" means "perform a matrix addition". But what if A and B are of incompatible sizes? Not surprisingly, MATLAB will complain with a statement such as:

```	??? Error using ==> +
Matrix dimensions must agree.
```

So the symbol "+" means "perform a matrix addition if you can and let me know if you can't".

## Assignment Statements

MATLAB uses a pattern common in many programming languages for assigning the value of an expression to a variable. The variable name is placed on the left of an equal sign and the expression on the right. The expression is evaluated and the result assigned to the variable name. In MATLAB, there is no need to declare a variable before assigning a value to it. If a variable has previously been assigned a value, the new value overrides the predecessor.

This may sound obvious, but consider that the term "value" now includes information concerning the size of matrix as well as its contents. Thus if A and B are of size {20*30} the statement:

```	C = A + B
```

Creates a variable named C that is also {20*30} and fills it with the appropriate values. If C already existed and was, say {20*15} it would be replaced with the required {20*30} matrix. In MATLAB, unlike some languages, there is no need to "pre-dimension" or "re-dimension" variables. It all happens without any explicit action on the part of the user.

## Case Sensitivity

MATLAB variable names are normally case-sensitive. Thus variable C is different from variable c. A variable name can have up to 19 characters, including letters, numbers and underscores. While it is tempting to use names such as FundReturns it is safer to choose instead fund_returns or to use the convention from the C language of capitalizing only second and subsequent words, as in fundReturns. In any event, a\Adopt a simple set of naming conventions so that you won't write one version of a name in one place and another later. If you do so, you may get lucky (e.g. the system will complain that you have asked for the value of an undefined variable) or you may not (e.g. you will assign the new value to a newly-created variable instead of the old one desired). In programming languages there are always tradeoffs. You don't have to declare variables in advance in MATLAB. This avoids a great deal of effort, but it allows nasty, difficult-to-detect errors to creep into your programs.

## Immediate and Deferred Execution

When MATLAB is invoked, the user is presented with an interactive environment. Enter a statement, press the carriage return ("ENTER") and the statement is immediately executed. Given the power that can be packed into one MATLAB statement, this is no small accomplishment. However, for many purposes it is desirable to store a set of MATLAB statements for use when needed.

The simplest form of this approach is the creation of a script file: a set of commands in a file with a name ending in .m (e.g. do_it.m). Once such a file exists and is stored on disk in a directory that MATLAB knows about (i.e. one on the "MATLAB path"), the user can simply type:

```	do_it
```

at the prompt in interactive mode. The statements will then be executed.

Even more powerful is the function file; this is also a file with an .m extension, but one that stores a function. For example, assume that the file val_port.m, stored in an appropriate directory, contains a function to produce the value of a portfolio, given a vector of holdings and a vector of prices. In interactive mode, one can then simply type:

```	v = val_port(holdings, prices);
```

MATLAB will realize that it doesn't have a built-in function named val_port and search the relevant directories for a file named val_port.m, then use the function contained in it.

Whenever possible, you should try to create "m-files" to do your work, since they can easily be re-used.

## Showing Values

If at any time you wish to see the contents of a variable, just type its name. MATLAB will do its best, although the result may take some space if the variable is a large matrix.

MATLAB likes to do this and will tell you what it has produced after an assignment statement unless you request otherwise. Thus if you type:

```	C = A + B
```

MATLAB will show you the value of C. This may be a bit daunting if C is, say, a 20 by 30 matrix. To surpress this, put a semicolon at the end of any assignment statement. For example:

```	C =  A + B;
```

## Initializing Matrices

If a matrix is small enough, one can provide initial values by simply typing them in. For example:

```            a = 3;
b = [ 1 2 3];
c = [ 4 ; 5 ; 6];
d = [ 1 2 3 ; 4 5 6];
```

Here, a is a scalar, b is a {1*3} row vector, c a {3*1} column vector, and d is a {2*3} matrix. Thus, typing "d" produces:

```	d =
1     2     3
4     5     6
```

The system for indicating matrix contents is very simple. Values separated by spaces are to be on the same row; those separated by semicolons are on to be on separate rows. All values are enclosed in square brackets.

## Making Matrices from Matrices

The general scheme for initializing matrices can be extended to include matrices as components. For example:

```     a = [1 2 3];
b = [4 5 6];
c = [a b];
```

gives:

```    c =
1     2     3     4     5     6
```

While:

```     d = [a ; b]
```

gives:

```     d =
1     2     3
4     5     6
```

Matrices can easily be "pasted" together in this manner -- a process that is both simple and easily understood by anyone reading a procedure (including its author). Of course, the sizes of the matrices must be compatible. If they are not, MATLAB will tell you.

## Using Portions of Matrices

Frequently one wishes to reference only a portion of a matrix. MATLAB provides simple and powerful ways to do so.

To reference a part of a matrix, give the matrix name followed by parentheses with expressions indicating the portion desired. The simplest case arises when only one element is wanted. For example, using d in the previous section:

```    d(1,2) equals 2
d(2,1) equals 4
```

In every case the first parenthesized expression indicates the row (or rows), while the second expression indicates the column (or columns). If a matrix is, in fact, a vector, a single expression may be given to indicate the desired element, but it is often wise to give both row and column information explicitly, even in such cases.

MATLAB's real power comes into play when more than a single element of a matrix is wanted. To indicate "all the rows" use a colon for the first expression. To indicate "all the columns", use a colon for the second expression. Thus, with:

```     d =
1     2     3
4     5      6

d(1,:) equals
1     2     3

d(:,2) equals
2
5
```

In fact, you may use any expression in this manner as long as it evaluates to a vector of valid row or column numbers. For example:

```    d(2,[2 3]) equals
5     6
d(2, [3 2]) equals
6     5
```

Variables may also be used as "subscripts". Thus:

```  if
z = [2 3]
then
d(2,z) equals
5     6
```

Particularly useful in this context (and others) is the construct that uses a colon to produce a string of consecutive integers. For example:

```   the statement:
x = 3:5
produces
x =
3     4     5
```

Thus:

```    d(1, 1:2) equals
1     2
```

## Text Strings

MATLAB is wonderful with numbers. It deals with text but you can tell that its heart isn't in it.

A variable in MATLAB is one of two types: numeric or string. A string matrix is like any other, except the elements in it are interpreted asASCII numbers. Thus the number 32 represents a space, the number 65 a capital A, etc.. To create a string variable, enclose a string of characters in "single" quotation marks (actually, apostrophes), thus:

```     stg = 'This is a string';
```

Since a string variable is in fact a row vector of numbers, it is possible to create a list of strings by creating a matrix in which each row is a separate string. As with all standard matrices, the rows must be of the same length. Thus:

```   the statement
x = ['ab' ; 'cd']
produces:
x =
ab
cd

while
x = ['ab' 'cd']
produces:
x =
abcd
as always.
```

## Matrix and Array Operations

The Mathworks uses the term matrix operation to refer to standard procedures such as matrix multiplication. The term array operation is reserved for element-by-element computations.

### Matrix Operations

Matrix transposition is as easy as adding a prime (apostrophe) to the name of the matrix. Thus:

```   if:
x =
1 2 3
then:
x' =
1
2
3
```

To add two matrices of the same size, use the plus (+) sign. To subtract one matrix from another of the same size, use a minus (-) sign. If a matrix needs to be "turned around" to conform, use its transpose. Thus, if A is {3*4} and B is {4*3}, the statement:

```       C = A + B
```

will get you the message:

```     ??? Error using ==> +
Matrix dimensions must agree.
```

while:

```       C = A + B'
```

will get you a new matrix.

There is one case in which addition or subtraction works when the components are of different sizes. If one is a scalar, it is added to or subtracted from all the elements in the other.

Matrix multiplication is indicated by an asterisk (*), commonly regarded in programming languages as a "times sign". With one exception the usual rules apply: the inner dimensions of the two operands must be the same. If they are not, you will be told so. The one allowed exception covers the case in which one of the components is a scalar. In this instance, the scalar value is multiplied by every element in the matrix, resulting in a new matrix of the same size.

MATLAB provides two notations for "matrix division" that provide rapid solutions to simultaneous equation or linear regression problems. They are better discussed in the context of such problems.

### Array Operations

To indicate an array (element-by-element) operation, precede a standard operator with a period (dot). Thus:

```  if x =
1     2     3
and y =
4     5     6
then:
x.*y =
4    10    18
the "dot product" of x and y.
```

You may divide all the elements in one matrix by the corresponding elements in another, producing a matrix of the same size, as in:

```      C = A ./ B
```

In each case, one of the operands may be a scalar. This proves handy when you wish to raise all the elements in a matrix to a power. For example:

```   if x =
1     2     3
then:
x.^2 =
1     4     9
```

MATLAB array operations include multiplication (.*), division (./) and exponentiation (.^). Array addition and subtraction are not needed (and in fact are not allowed), since they would simply duplicate the operations of matrix addition and subtraction.

## Using Functions

MATLAB has a number of built-in functions -- many of which are very powerful. Some provide one (matrix) answer; others provide two or more.

You may use any function in an expression. If it returns one answer, that answer will be used. The sum function provides an example:

```   if x =
1
2
3
then the statement:
y =sum(x) + 10
will produce:
y =
16
```

Some functions, such as max provide more than one answer. If such a function is included in an expression, only the first answer will be used. For example:

```
if x =
1     4     3
the statement:
z = 10 + max(x)
will produce:
z =
14
```

To get all the answers from a function that provides more than one, use a multiple assignment statement in which the variables that are to receive the answers are listed to the left of the equal sign, enclosed in square brackets, and the function is on the right. For example:

```
if x =
1     4     3
the statement:
[y n] = max(x)
will produce:
y =
4
n =
2
```

In this case, y is the maximum value in x, and n indicates the position in which it was found.

Many of MATLAB's built-in functions, such as sum, min, max, and mean have natural interpretations when applied to a vector. If a matrix is given as an argument to such a function, its procedure is applied separately to each column, and a row vector of results returned. Thus:

```     if x =
1     2     3
4     5     6
then :
sum(x) =
5     7     9
```

Some functions provide no answers per se. For example, to plot a vector y against a vector x, simply use the statement:

```     plot(x,y)
```

which will produce the desired cross-plot.

Note that in this case, two arguments (the items in the parentheses after the function name) were provided as inputs to the function. Each function needs a specific number of inputs. However, some have been programmed to react appropriately when fewer are given. For example, to plot y against (1,2,3...), you can use the statement:

```     plot(y)
```

There are many built-in functions in MATLAB. Among them, the following are particularly useful for Macro-Investment Analysis:

• ones
ones matrix
• zeros
zeros matrix
• size
size of a matrix
• diag
diagonal elements of a matrix
• inv
matrix inverse
• rand
uniformly distributed random numbers
• randn
normally distributed random numbers
• cumprod
cumulative product of elements
• cumsum
cumulative sum of elements
• max
largest component
• min
smallest component
• sum
sum of elements
• mean
average or mean value
• median
median value
• std
standard deviation
• sort
sort in ascending order
• find
find indices of nonzero entries
• corrcoef
correlation coefficients
• cov
covariance matrix

Not listed, but of great use, are the many functions that provide plots of data in either two or three dimensions, as well as a number of more specialized functions. However, this list should serve to whet the Analyst's appetite. The full list of functions and information on each one can be obtained via MATLAB's on-line help system.

## Logical and Relational Operations on Matrices

MATLAB offers six relational operators:

• < : less than
• <= : less than or equal to
• > : greater than
• >= : greater than or equal to
• == : equal
• ~= : not equal

Note carefully the difference between the double equality and the single equality. Thus A==B should be read "A is equal to B", while A=B should be read "A should be assigned the value of B". The former is a logical relation, the latter an assignment statement.

Whenever MATLAB encounters a relational operator, it produces a one if the expression is true and a zero if the expression is false. Thus:

```   the statement:
x = 1 < 3 produces: x=1, while
x = 1 > 3 produces: x=0
```

Relational operators can be used on matrices, as long as they are of the same size. Operations are performed element-by-element, resulting a matrix with ones in positions for which the relation was true and zeros in positions for which the relation was false. Thus:

```    if A =
1     2
3     4
and B =
3     1
2     2
the statement:
C = A > B
produces:
C =
0     1
1     1
```

One or both of the operands connected by a relational operator can be a scalar. Thus:

```     if A =
1     2
3     4
the statement:
C = A > 2
produces:
C =
0     0
1     1
```

One may also use logical operators of which there are three:

• & : and
• | : or
• ~ : not

Each works with matrices on an element-by-element basis and conforms to the ordinary rules of logic, treating any non-zero element as true and any zero element as false.

Relational and logical operators are used frequently with If statements (described below) and scalar variables, as in more mundane programming languages. But the ability to use them with matrices offers major advantages in some Investment applications.

## Sorting Matrices

To sort a matrix in ascending order, use the sort function. If the argument is a vector, the result will be a new vector with the items in the desired order. If it is a matrix, the result will be a new matrix in which each column will contain the contents of the corresponding column from the old matrix, in ascending order. Note that in the latter case, each column is, in effect, sorted separately. Thus:

```   if x =
1     5
3     2
2     8
the statement:
y=sort(x)
will produce:
y =
1     2
2     5
3     8
```

To obtain a record of the rows from which each of the sorted elements came, use a multiple assignment to get the second output of the function. For the case above:

```   the statement:
[y r] = sort(x)
would produce y as before and
r =
1     2
3     1
2     3
```

Thus the second item in the sorted list in column 1 came from row 3, etc..

## Controlling Execution Flow

It is possible to do a great deal in MATLAB by simply executing statements involving matrix expressions, one after the other, However, there are cases in which one simply must substitute some non-sequential order. To facilitate this, MATLAB provides three relatively standard methods for controlling program flow: For Loops, While Loops, and If statements

### For Loops

The most common use of a For Loop arises when a set of statements is to be repeated a fixed number of times, as in:

```   for j= 1:n
.......
end
```

There are fancier ways to use For Loops, but for our purposes, the standard one suffices.

### While Loops

A While Loop contains statements to be executed as long as a stated condition remains true, as in:

```   while x > 0.5
.......
end
```

It is, of course, crucial that at some point a statement will be executed that will cause the condition in the While statement to be false. If this is not the case, you have created an infinite loop -- one that will go merrily on until you pull the plug.

For readability, it is sometimes useful to create variables for TRUE and FALSE, then use them in a While Loop. For example:

```   true = 1==1;
false = 1==0;
.....
done = false;
while not done
........
end
```

Of course, somewhere in the While loop there should be a statement that will at some point set done equal to true.

### If Statements

A If Statement provides a method for executing certain statements if a condition is true and other statements (or none) if the condition is false. For example:

```     If x > 0.5
........
else
.......
end
```

In this case, if x is greater than 0.5 the first set of statements will be executed; if not, the second set will be executed.

A simpler version omits the "else section", as in:

```     If x > 0.5
........
end
```

Here, the statements will be executed if (but only if) x exceeds 0.5.

### Nesting

All three of these structures allow nesting, in which one type of structure lies within another. For example:

```     for j = 1:n
for k = 1:n
if x(j,k) > 0.5
x(j,k) = 1.5;
end
end
end
```

The indentation is for the reader's benefit, but highly recommended in this and other situations. MATLAB will pair up end statements with preceding for, while, or if statements in a last-come-first-served manner. It is up to the programmer to ensure that this will give the desired results. Indenting can help, but hardly guarantees success on every occasion.

While it is tempting for those with experience in traditional programming languages to take the easy way out, using For and While loops for mathematical operations, this temptation should be resisted strenuously. For example, instead of:

```  port_val = 0;
for j = 1:n
port_val = port_val + ( holdings(j) * prices(j));
end
```

write:

```    port_val = holdings*prices;
```

The latter is more succinct, far clearer, and will run much faster. MATLAB performs matrix operations at blinding speed, but can be downright glacial at times when loops are to be executed a great many times, since it must do a certain amount of translation of each statement every time it is encountered.

## Writing Functions

The power of MATLAB really comes into play when you add your own functions to enhance the language. Once a function m-file is written, debugged, and placed in an appropriate directory, it is for all practical purposes part of your version of MATLAB.

A function file starts with a line declaring the function, its arguments and its outputs. There follow the statements required to produce the outputs from the inputs (arguments). That's it.

Here is a simple example:

```   function y = port_val(holdings,prices)
y = holdings*prices;
```

Of course, this will only work if the holdings and prices vectors or matrices are compatible for matrix multiplication. A more complex version could examine the sizes of these two matrices, then use transposes, etc. as required.

It is important to note that the argument and output names used in a function file are strictly local variables that exist only within the function itself. Thus in a program, one could write the statement:

```       v =  port_val(h,p);
```

The first matrix in the argument list in this calling statement (here, h) would be assigned to the first argument in the function (here, holdings) while the second matrix in the calling statement (p) would be assigned to the second matrix in the function (prices). There is no need for the names to be the same in any respect. Moreover, the function cannot change the original arguments in any way. It can only return information via its output.

This function returns only one output, called y internally. However, the resultant matrix will be substituted for the entire argument "call" in any expression.

If a function is to return two or more arguments, simply assign them names in the declaration line, as in:

```   function [total_val, avg_val] = port_val(holdings,prices)
total_val = holdings*prices;
avg_val = total_val/size(holdings,2);
```

This can still be used as in the earlier case if only the total value is desired. To get both the total value and the average value per position, a program could use a statement such as:

```   [tval aval] = port_val( h,p);
```

Note that as with inputs, the correspondence between outputs in the calling statement and the function itself is strictly by order. When the function has finished its work, its output values are assigned to the variables in the calling statement.

Variables other than inputs and arguments may be included in functions, as needed. They are strictly local to the function and have no existence outside it. Indeed, a variable in a function may have the same name as one in another place; the two will coexist with neither bothering the other. While MATLAB provides for the use of "global variables", their use is widely discouraged and will not be treated here.

## Comments and Help

It is an excellent idea to include comments throughout any m-file. To do so, use the percent (%) sign. Everything after it up to the end of the line will be ignored by MATLAB.

The first several lines after each function header should provide a brief description of the function and its use. Once the function has been placed in an appropriate directory, a user need only type help followed by the function name to be shown all the initial comment lines (up to the first non-comment or totally blank line). Thus if there is a function named port_val, the user can get this information by typing:

```      help port_val
```

To provide even more assistance, create a script file with nothing but comment lines, each giving the name and a brief description of all your functions and scripts. If this were named mia_fun, the user could simply type:

```      help mia_fun
```

to get a list of your functions, then type help function name to get more details on any specific function.

## Data Input and Output

There are many ways to get information into and out of the MATLAB environment. We will cover only the simpler ones here.

### Data Input

The most straightforward way to get information into MATLAB is to type it in "command mode". For example:

```   prices = [ 12.50 37.875  12.25];
assets = ['cash  ';'bonds ' ; 'stocks'];
```

MATLAB even makes it easy to enter matrices in a more normal form by treating carriage returns as semicolons within brackets. Thus:

```     holdings = [ 100 200
300 400
500 600 ]
```

will create a {3*2} matrix, as desired.

A second way to get data into MATLAB is to create a script file with the required statements, such as the one above. This can be done with any text processor. Large matrices of data can even be "cut out" of databases, spreadsheets, etc. then edited to include the desired variable names, square brackets and the like. Once the file or files are saved with .m names they only have to be invoked to bring the data into MATLAB.

Next up the chain of complexity is the use of a flat file which stores data for a matrix. Such a file should have numeric ascii text characters, with each element in a row separated from its neighbor with a space and each row on a separate line. Say, for example, that you have stored the elements of a matrix in a file named test.txt in a directory on the MATLAB path. Then the statement:

```    load test.txt
```

will create a matrix named test containing the data.

### Data Output

A simple way to output data is to display a matrix. This can be accomplished by either giving its name (without a semicolon) in interactive mode. Alternatively you can use the disp function, which shows values without the variable name, as in:

```    disp(test);
```

For prettier output, MATLAB has various functions for creating strings from numbers, formatting data, etc.. Function pmat can produce small tables with string identifiers on the borders.

If you want to save almost everything that appears on your screen, issue the command:

```    diary filename
```

where filename represents the name of a new file that will receive the subsequent output. When you are through, issue the command:

```    diary off
```

Later, at your leisure, you may use a text editor to extract data, commands, etc. to data files, script or function files, and so on.

There are, of course, other alternatives. If you are in an environment (such as a Windows system) that allows material to be copied from one program and pasted into another, this may suffice.

To create a flat file containing the data from a matrix use the -ascii version of the save command. For example:

```     save newdata.txt test -ascii
```

will save the matrix named test in the file named newdata.txt.

Finally, you may save all or part of the material from a MATLAB session in MATLAB's own mat file format. To save all the variables in a file named temp.mat, issue the command:

```     save temp
```

At some later session you may load all this information by simply issuing the command:

```     load temp
```

To save only one or more matrices in this manner, list their names after the file name. Thus:

```     save temp prices  holdings  portval
```

would save only these three matrices in file temp.mat. Subsequent use of the command:

```     load temp
```

would restore the three named matrices, with their values intact.

There are more sophisticated ways to move information into and out of MATLAB, but they can be left to others.

## MATLAB Function Library

We provide a number of MATLAB functions that may prove of value to the Macro-Investment Analyst and, possibly, others. The user is advised to proceed with caution when using any of them.