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.

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

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

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:

onesones matrix

zeroszeros matrix

sizesize of a matrix

diagdiagonal elements of a matrix

inv matrix inverse

randuniformly distributed random numbers

randn normally distributed random numbers

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

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:

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:

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:

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:

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:

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.

Data Input

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.