- Introduction
- MATLAB Versions
- Matrices as Fundamental Objects
- Matrix Operations
- Assignment Statements
- Case Sensitivity
- Immediate and Deferred Execution
- Showing Values
- Initializing Matrices
- Making Matrices from Matrices
- Using Portions of Matrices
- Text Strings
- Matrix and Array Operations
- Using Functions
- Logical and Relational Operations on Matrices
- Sorting Matrices
- Controlling Execution Flow
- Writing Functions
- Comments and Help
- Data Input and Output
- MATLAB Function Library

**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.

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.

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.

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".

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.

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.

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.

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;

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.

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.

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

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 as*ASCII 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.

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 *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.

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.

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.

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.

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..

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*

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.

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.

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.

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.

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.

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.

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

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.

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.

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.