This document is based on one prepared by David Hart of the
STAT/MATH Center at Indiana University.

Modifications are by Malcolm Good,
Department of Mechanical and Manufacturing Engineering, University of
Melbourne

MATLAB is a computer program for people doing numerical computation. It began as a "MATrix LABoratory" program, intended to provide interactive access to the libraries Linpack and Eispack. These are carefully tested, high-quality programming packages for solving linear equations and eigenvalue problems. The goal of MATLAB is to enable scientists and engineers to use matrix-based techniques to solve problems, using state-of-the-art code, without having to write programs in traditional languages like C and Fortran. More capabilities have been added as time has passed -- many more commands, and very fine graphics capabilities.

MATLAB is available for many different kinds of computers. In the Department of Mechanical and Manufacturing Engineering (DoMME) at the University of Melbourne, we have MATLAB V5.2 on the PCs in the ECR PC Lab, the Unix workstations in ECR (accessible also via an X-term window on the NT Pentiums in ECR, and the Windows 95 PCs in the Mechatronics Lab. Student Editions of MATLAB (and the associated program SIMULINK) are available from local bookstores for your personal Windows and Macintosh systems. Students enrolled in Controls subjects in DoMME may borrow a Classroom Kit to install on their own Windows system. Note that the Classroom Kit comes without hardcopy documentation. Extensive on-line documentation is available, but consumes a lot of disk space! The Student Editions are highly recommended.

This document is intended to be used while sitting at a computer terminal running either Win95 or the X windows system. It is assumed that you will enter the commands shown, and then think about the result; if you have any questions, have a look at a set of Frequently Asked Questions (FAQ).

To start the program type `matlab` at the UNIX prompt, or select
**Start/Programs/Matlab** on a Win95 PC. The system should respond (after a
pause perhaps) with something like:

To get started, type one of these commands: helpwin, helpdesk, or demo. For information on all of the MathWorks products, type tour. >>

[The ">>" is MATLAB's prompt, you won't need to type it].

To stop MATLAB and return to the operating system, use

>> quit % or exit

**Arithmetic **uses some fairly standard notation. More than one command may
be entered on a single line, if they are separated by commas.

>> 2+3 >> 3*4, 4^2

Powers are performed before division and multiplication, which are done before subtraction and addition.

>> 2+3*4^2

The arrow keys allow "command-line editing," which cuts down on the amount of typing required, and allows easy error correction. Press the "up" arrow, and add "/2." What will this produce?

>> 2+3*4^2/2

Parentheses may be used to group terms, or to make them more readable.

>> (2 + 3*4^2)/2

The equality sign is used to assign values to **variables**.

>> x = 3 >> y = x^2 >> y/x

If no other name is given, an answer is saved in a variable named "ans."

>> ans, z=2*ans, ans

Here `z` was defined in terms of `ans`. The result was called
`z`, so `ans` was unchanged.

To get a list of your variables, use the Workspace Browser [one of the buttons, in the NT version], or one of

>> who, whos

In MATLAB, like C or Fortran, variables must have a value [which might be
numerical, or a string of characters, for example]. Complex numbers are
automatically available [by default, both i and j are initially aliased to
sqrt(-1)]. **All arithmetic is done to double precision **[about 16 decimal
digits], even though results are normally displayed in a shorter form.

>> a=sqrt(2) >> format long, b=sqrt(2) >> a-b >> format short

To find out about this kind of thing, consult the **help **system. There's
even an HTML version! There's also a "lookfor" command, so that you don't have
to guess the topic name precisely.

>> help >> help general >> doc

The following command will make a record of your session, saving all the dialog between you and MATLAB in a file named "session.txt". Be sure that you will be writing to an appropriate directory. You can change your local directory from within MATLAB with the usual cd command.

>> diary session.txt

To save the value of the variable "`x`" to a plain text file named
"x.value" use

>> save x.value x -ascii

To save all variables in a file named "mysession.mat" in reloadable format, use

>> save mysession

To restore the session, use

>> load mysession

Then, to see the saved files from your session, on UNIX systems type the commands:

% more session.txt % more x.value

Under Windows, open the appropriate file with Notepad.

A matrix is a rectangular array of numbers: for example,

[ 1 2 3 ] [ 4 5 6 ]

defines a matrix with 2 rows, 3 columns, 6 elements. We will refer you to your Mathematics subjects for an explanation of the arithmetic of matrices, what they have to do with anything [they're one of the basic tools of science].

MATLAB is designed to make matrix manipulation as simple as possible. Every MATLAB variable refers to a matrix [a 1 row by 1 column matrix is a number]. Start MATLAB again, and enter the following command.

>> a = [1,2,3; 4 5 6]

Note that:

- the elements of a matrix being entered are enclosed by brackets;
- a matrix is entered in "row-major order" [ie all of the first row, then all of the second row, etc];
- rows are separated by a semicolon [or a newline], and the elements of the
row may be separated by either a comma or a space. [
*Caution:*Watch out for extra spaces!]

The element in the i'th row and j'th column of `a` is referred to in
the usual way:

>> a(1,2), a(2,3)

It's very easy to modify matrices:

>> a(2,3) = 10

The **transpose **of a matrix is the result of interchanging rows and
columns. MATLAB denotes the [conjugate] transpose by following the matrix with
the single-quote [apostrophe].

>> a' >> b=[1+i 2 + 2*i 3 - 3*i], b'

New matrices may be formed out of old ones, in many ways. Enter the following commands; before pressing the enter key, try to predict their results!

>> [a; a; a] >> [a, a, a] >> c = [a; 7 8 9] >> [a', b] >> [ [a; a; a], [b; b] ]

There are many built-in matrix **constructions. **Here are a few:

>> rand(1,3), rand(2) >> zeros(3) >> ones(3,2) >> eye(3), eye(2,3) >> magic(3) >> hilb(5)

This last command creates the 5 by 5 "Hilbert matrix," a favourite example in numerical analysis courses.

Use a **semicolon** to suppress output:

>> s = zeros(20,25);

This is valuable, when working with large matrices. If you forget it, and start printing screenfuls of unwanted data, Control-C is MATLAB's "break" key.

To get more information on these, look at the help pages for elementary and special matrices.

>> help elmat >> help specmat

A central part of MATLAB syntax is the "**colon **operator," which
produces a list.

>> -3:3

The default increment is by 1, but that can be changed.

>> x = -3 : .3 : 3

This can be read: "x is the name of the list, which begins at -3, and whose entries increase by .3, until 3 is surpassed." You may think of x as a list, a vector, or a matrix, whichever you like.

You may wish use this construction to extract "subvectors," as follows.

>> x(2:12) >> x(9:-2:1)

See if you can predict the result of the following.

[Hint: what will x(2)
be? x(10)?].

>> x=10:100; >> x(40:5:60)

The colon notation can also be combined with the earlier method of constructing matrices.

>> a = [1:6 ; 2:7 ; 4:9]

A very common use of the colon notation is to extract rows, or columns, as a
sort of "wild-card" operator which produces a default list. The following
command produces the matrix `a`, followed by its first row [with all of
its columns], and then its second column [with all of its rows]. What do you
think s(6:7, 2:4) does?

>> a, a(1,:), a(:,2) >> s = rand(10,5); s(6:7, 2:4)

Matrices may also be constructed by programming. Here is an example, creating
a "program **loop**."

>> for i=1:10, >> for j=1:10, >> t(i,j) = i/j; >> end >> end

There are actually two loops here, with one nested inside the other; they define t(1,1), t(1,2), t(1,3) ... t(1,10), t(2,1), t(2,2) ... , t(2,10), ... t(10,10) [in that order].

>> t

If necessary, re-enter the matrices

>> a = [1 2 3 ; 4 5 6 ; 7 8 10], b = [1 1 1]'

Scalars multiply matrices as expected, and matrices may be added in the usual way; both are done "element by element."

>> 2*a, a/4 >> a + [b,b,b]

Scalars added to matrices produce a "strange" result, but one that is sometimes useful; the scalar is added to every element.

>> a+1, b+2

Matrix multiplication requires that the sizes match. If they don't, an error message is generated.

>> a*b, b*a >> b'*a >> a*a', a'*a >> b'*b, b*b'

To perform an operation on a matrix element-by-element, precede it by a period.

>> a^2, a.^2 >> a.*a, b.*b >> 1 ./ a >> 1./a.^2

One of the main uses of matrices is in representing **systems of linear
equations**. If a is a matrix containing the coefficients of a system of
linear equations, x is a column vector containing the "unknowns," and b is the
column vector of "right-hand sides," the constant terms, then the matrix
equation

a x =b

represents the system of equations. MATLAB provides a very efficient mechanism for solving linear equations:

>> x = a \ b

This can be read "x equals a-inverse times b." To verify this assertion, look at

>> a*x, a*x - b

Change b, and do the problem again.

>> b = [1 1 0]' >> x = a\b >> a*x, a*x - b

If there is no solution, a "least-squares" solution is provided [a*x - b is as small as possible]. Enter

>> a(3,3) = 9

[which makes the matrix singular] and do those again. [Use the up-arrow, to recall the commands without retyping them].

There is a related problem, to solve x a = b (given a and b), which is done with

>> x = b / a

This can be read "B times A-inverse." Again, if there is no solution, a least-squares solution is found.

Note that the matrix sizes must still agree, i.e. *a x = b* must make
sense.

There are a number of built-in matrix functions, for example the determinant, rank, nullspace, and condition number.

>> det(a) >> rank(a) >> norm(a) >> null(a)

Enter

>> a(3,3) = 10

[which makes the matrix nonsingular] and do those again.

Other valuable functions find the inverse, **eigenvalues **and
eigenvectors of a matrix.

>> h=hilb(5) >> cond(a) >> inv(h) >> eig(h)

The "eig" function has two forms of output. The last command produced a vector of eigenvalues. The next command produces two matrices, the first containing the eigenvectors as its columns, and the second containing the eigenvalues, along its diagonal.

>> [v,d]=eig(h)

The matrix, h, times the first eigenvector, v(:,1), should equal the first eigenvalue, d(1,1), times that same eigenvector.

>> h*v(:,1) >> d(1,1)*v(:,1) >> v*d*inv(v), inv(v)*h*v

"**Round-off error**" is a primary concern in numerical computing. MATLAB
does numerical computation, which is to say, it works with limited precision;
all decimal expansions are truncated at the sixteenth place [roughly speaking].
Even if this is acceptable for any single calculation, its effects may
accumulate with unacceptable consequences. The machine's round-off, the smallest
distinguishable difference between two numbers as represented in MATLAB, is
denoted "eps".

>> help eps >> eps

We can check the assertion just made about eigenvectors and eigenvalues, as follows.

>> h*v(:,1) - d(1,1)*v(:,1)

This is "the zero vector, modulo round-off error."

MATLAB has outstanding graphics capabilities [you must be using a terminal which supports graphics, to use them]. Start with

>> x = -10:.1:10; >> plot( x.^2 ) >> figure >> plot( x, x.^2 ) >> figure >> plot( x.^2, x )

Note that x must be assigned values, before the plot command is issued
[although you could use` plot( (-10 : .1 : 10) .^ 2 ) `if you
*really* really wanted to].

>> plot( x, x.*sin(x) ) >> plot( x.*cos(x), x.*sin(x) ) >> comet( x.*cos(x), x.*sin(x) ) >> plot3(x.*cos(x),x.*sin(x),x)

Functions of **two variables **may be plotted, as well, but some "setup"
is required!

>> [x y] = meshgrid(-3:.1:3, -3:.1:3); >> z = x.^2 - y.^2; >> mesh(x,y,z) >> plot3(x,y,z) >> surf(x,y,z) >> contour(z) >> help slice

There's a very interesting example, in the help page for slice; use the mouse to cut and paste it to the MATLAB prompt.

The following commands bring up lists of useful graphics commands [each has a help page of its own].

>> help graph2d >> help graph3d >> help graphics

To **print **MATLAB graphics, just enter "print" at the MATLAB prompt; the
current figure window will be sent to the printer.

If you are at a workstation where printing is not supported, you can save the current figure window with a command like:

>> print -dmfile MyPlot

This will create two files in your current working directory: MyPlot.m and MyPlot.mat. If these are in your working directory (or on the MATLAB path) in some later session, you can regenerate the original figure window by invoking the m-file:

>> MyPlot

Type

>> help print

for a comprehensive list of **print** options.

MATLAB statements can be prepared with any editor, and stored in a file for
later use. The file is referred to as a script, or an "m-file" (since they must
have names of the form `foo.m`). Writing m-files will make you much more
productive.

Using your favorite editor, create the following file, named sketch.m:

[x y] = meshgrid(-3:.1:3, -3:.1:3); z = x.^2 - y.^2; mesh(x,y,z);

Then start MATLAB from the directory containing this file, and enter

>> sketch

The result is the same as if you had entered the three lines of the file, at the prompt.

Note that MATLAB V5 has a built-in editor which provides powerful de-bugging
facilities. To access the MATLAB Editor/Debugger, choose **New/M-file** or
**Open¼ **from the **File** dropdown menu in the
MATLAB Command Window.

You can also enter **data **this way: if a file named mymatrix.m in the
current working directory contains the lines

A = [2 3 4; 5 6 7; 8 9 0] inv(A) quit

then the command

>> mymatrix

reads that file, generates A and the inverse of A, and quits MATLAB [quitting is optional]. You may prefer to do this, if you use the same data repeatedly, or have an editor that you like to use. You can use Control-Z to suspend MATLAB, then edit the file, and then use "fg" to bring MATLAB back to the foreground, to run it.

MATLAB may be ran in "**batch **mode," in a very similar way. If a file
named "test.in" contains the [non-graphics] commands you want processed, at the
UNIX prompt type:

% matlab < mymatrix.m > homework.out

This is read, "Run MATLAB, with input from test.in, and output to test.out."
The input file does not need to be named "something-dot-m," but it **must**
end with "quit"!

**Functions **are like scripts, but are compiled the first time they are used
in a given session, for speed. Create a file, named sqroot.m, containing the
following lines.

function sqroot(x) % Compute square root by Newton's method % Initial guess xstart = 1; for i = 1:100 xnew = ( xstart + x/xstart)/2; disp(xnew); if abs(xnew - xstart)/xnew < eps, break, end; xstart = xnew; end

Save this file, start MATLAB, and enter the commands

>> format long >> sqroot(19)

A good exercise would be to create the STAT function described in the help file for function. Note that

>> x=rand(1,10); >> stat(x)

and

>> [m,sd] = stat(x)

produce different results.

The "m-files" which come with MATLAB provide lots of examples! To find their location, use

>> path

This will also lead you to some really nifty demos.

The web browser that appears as a result of the "doc" command contains a link to the MathWorks Home Page, which offers answers to Frequently Asked Questions, and more.

Some books which may be useful are

**MATLAB Primer**, by Kermit Sigmon [CRC Press, 1994],**Matrices and MATLAB, a Tutorial**, by Marvin Markus [Prentice-Hall, 1993],**Solving Problems in Scientific Computing Using Maple and MATLAB**, ed. Walter Gander and Jiri Hrebicek [Springer-Verlag, 1993].- Last revised: Friday, 16 October 1998, mcg@mame.mu.oz.au