Matlab Introduction

Matlab is both a powerful computational environment and a programming language that easily handles matrix and complex arithmetic.  It is a large software package that has many advanced features built-in, and it has become a standard tool for many working in science or engineering disciplines.  Among other things, it allows easy plotting in both two and three dimensions.

Matlab has two different methods for executing commands:  interactive mode and batch mode.  In interactive mode, commands are typed (or cut-and-pasted) into the 'command window'.  In batch mode, a series of commands are saved in a text file (either using Matlab's built-in editor, or another text editor such as Emacs) with a '.m' extension.  The batch commands in a file are then executed by typing the name of the file at the Matlab command prompt.  The advantage to using a '.m' file is that you can make small changes to your code (even in different Matlab sessions) without having to remember and retype the entire set of commands.  Also, when using Matlab's built-in editor, there are simple debugging tools that can come in handy when your programs start getting large and complicated.  More on writing .m files later.

Scalar Variables and Arithmetic Operators

Scalar variables are assigned in the obvious way:

>> x = 7
x =
7

The >> is Matlab's command prompt.  Notice that Matlab echos back to you the value of the assignment you have made.  This can be helpful occasionally, but will generally be unwieldy when working with vectors.  By placing a semicolon at the end of a statement, you can suppress this verbose behavior.

>> x = 7;

Variables in Matlab follow the usual naming conventions.  Any combination of letters, numbers and underscore symbols ('_') can be used, as long as the first character is a letter.  Note also that variable names are case sensitive ('X' is different from 'x').

All of the expected scalar arithmetic operators are available:

>> 2*x
ans =
14

>> x^2
ans =
49

Notice that the multiply operation is not implied as it is in some other computational environments and the '*' operator has to be specified (typing '>>2x' will result in an error).  This is also a good time to point out that Matlab remembers the commands that you are entering and you can use the up-arrow button to scroll through them and edit them for re-entry.  This is very handy, especially when you are repeatedly making minor changes to a long command line.

There are a few predefined variables in Matlab that you will use often: pi, i, and j.   Both i and j are defined to be the square-root of -1 and pi is defined as the usual 3.1416... .  These variables can be assigned other values, so the statement

>> pi = 4;

is valid.  Care is needed to avoid changing a predefined variable and then forgetting about that change later.  That may seem unreasonable with pi, but i and j are both natural variables to use as indices and they are often changed.  A useful command is the 'clear', or 'clear all' command.  Typing either of these at the command prompt will remove all current variables from Matlab's memory and reset predefined variables to their original values.  The clear command can also remove one specific variable from memory.  The command

>> clear x

would only remove the variable named 'x' from Matlab's memory.

Matrix Variables and Arithmetic Operators

Another useful Matlab command is 'whos', which will report the names and dimensions of all variables currently in Matlab's memory.  After typing the command at the prompt we see:

>> whos
Name      Size         Bytes  Class

x         1x1              8  double array

Grand total is 1 elements using 8 bytes

The important thing to note right now is that the size is given as '1x1'.  Matlab is really designed to work with vectors and matrices, and a scalar variable is just a special case of a 1x1 dimensional vector.  To assign a vector containing the first 5 integers to the variable x, we could type this command:

>> x = [1 2 3 2^2 2*3-1]
x =
1     2     3     4     5

We won't have much occasion to operate on matrices that are higher dimension, but if you wanted to create a 2-D matrix you could use a command something like:

>> A = [1 2 3; 4 5 6]
A =
1     2     3
4     5     6

To create larger vectors than the toy examples above (say, the integers up to 100), we would need to type a lot of numbers.  Not surprisingly, there are easier ways built in to create vectors.  To create the same 5-element vector we did above, we could also type:

>> x = [1:5]
x =
1     2     3     4     5

The colon operator creates vectors of equally spaced elements given a beginning point, and maximum ending point and the step size in between elements.  Specifically, [b:s:e] creates the vector [b b+s b+2*s ... e].  If no step size is specified (as in the example above), a step of 1 is assumed.  So, the command [1:2:10] would create the vector of odd integers less than 10, [1 3 5 7 9] and  the command [1:3:10] would create the vector of elements [1 4 7 10].

Let's create the vector of odd elements mentioned above:

>> x_odd = [1:2:10]
x_odd =
1     3     5     7     9

You can access any  element by indexing the vector name with parenthesis (indexing starts from one, not from zero as in many other programming languages).  For instance,  to access the 3rd element, we would type:

>> x_odd(3)
ans =
5

We can also access a range of elements (a subset of the original vector) by using the colon operator and giving a starting and ending index.

>> x_odd(2:4)
ans =
3     5     7

If we want to do simple arithmetic on a vector and a scalar, the expected things happen,

>> 3+[1 2 3]
ans =
4     5     6

>> 3*[1 2 3]
ans =
3     6     9

and the addition or subtraction of matrices is possible as long as they are the same size:

>> [1 2 3]+[4 5 6]
ans =
5     7     9

The operators '*' and '/' actually represent matrix multiplication and division which is not typically what we will need in this course.  However, a common task will be to form a new vector by multiplying (or dividing) the elements of two vectors together, and the special operators '.*' and './' serve that purpose.

>> [1 2 3].*[4 5 6]
ans =
4    10    18

>> [1 2 3]./[4 5 6]
ans =
0.2500    0.4000    0.5000

Beware that the operator '^' is a shortcut for repeated matrix multiplications ('*'), whereas the operator '.^' is the shortcut for repeated element-by-element multiplications ('.*').  So, to square all of the elements in a vector, we would use

>> [1 2 3].^2
ans =
1     4     9

Built-in Commands

Matlab has many built-in commands to do both elementary mathematical operations and also complex scientific calculations.  The 'help' command will be useful in learning about built-in commands.  By typing help at the command prompt, you are given a list of the different categories that Matlab commands fall into (e.g., general, elementary matrix operations, elementary math functions, graphics, etc.).  Notice that there are probably even specific toolboxes included with your Matlab package for performing computations for disciplines such as signal processing.  To see all of the commands under a certain topic, type 'help topic'.  To get a description of a specific command, type 'help command'.

We'll look at a couple of example commands.  First, the square-root command, sqrt.  To calculate the square root of a number, type:

>> sqrt(2)
ans =
1.4142

Again, to illustrate that Matlab understands complex numbers, we can have it calculate the root of a negative number:

>> sqrt(-9)
ans =
0 + 3.0000i

Many Matlab commands that operate on scalars will also operate element-by-element if you give it a vector.  For instance:

>> sqrt([1 2 4 6])
ans =
1.0000    1.4142    2.0000    2.4495

>> sqrt([1:8])
ans =
1.0000    1.4142    1.7321    2.0000    2.2361    2.4495    2.6458    2.8284

Another useful command is sin function, which also operates on a vector.

>> sin([pi/4 pi/2 pi])
ans =
0.7071    1.0000    0.0000

It is important to realize that digital signals are really just a collection of points and can be represented by a vector.  Because Matlab allows functions like sin and sqrt (as well as many others) to operate on vectors, many of the signal definitions and calculation we would like to perform are very straight-forward.  We will illustrate this a little more explicitly in the next section.

Signals, Plotting and Batch Operation

We will now use the elementary tools in Matlab to build a basic signal we have talked about in class.  All of the commands given in this section are already written in the file sinplot.m.  They can be executed in batch by typing sinplot at the command prompt.  If the file is not found, use the 'current directory' browser at the top of the Matlab window to make the current directory the one where the file lives.

First, we will define a signal which is a 2 Hz sinewave over the interval [0,1] seconds:

>> t   = [0:.01:1];                % independent (time) variable
>> A = 8;                          % amplitude

>> f_1 = 2;                        % create a 2 Hz sine wave lasting 1 sec
>> s_1 = A*sin(2*pi*f_1*t);

Anything following a '%' symbol is a comment and will be ignored by Matlab.  A 4 Hz sinewave with the same amplitude will also be defined:

>> f_2 = 4;                        % create a 4 Hz sine wave lasting 1 sec
>> s_2 = A*sin(2*pi*f_2*t);

There are a few commands necessary to do basic plotting of these signals.  The figure command will bring up a new figure window and the close command closes a specific window ('close all' closes all open windows).  The subplot(r, c, p) command allows many plots to be 'tiled' into r rows and c columns on one figure window.  After this command is issued, any succeeding commands will affect the pth tile.  The plot(x,y) command will then plot the equal-length vectors x and y on the appropriate axis and in the obvious way.  The two sinewaves created above are then plotted along with the sum of the two signals in separate tiles with the commands:

%plot the 2 Hz sine wave in the top panel
figure
subplot(3,1,1)
plot(t, s_1)
title('2 Hz sine wave')
ylabel('Amplitude')

%plot the 4 Hz sine wave in the middle panel
subplot(3,1,2)
plot(t, s_2)
title('4 Hz sine wave')
ylabel('Amplitude')

%plot the summed sine waves in the bottom panel
subplot(3,1,3)
plot(t, s_1+s_2)
title('Summed sine waves')
ylabel('Amplitude')
xlabel('Time (s)')

The commands title, xlabel, and ylabel  all take strings as arguments and apply the appropriate label to the top, x-axis or y-axis of the current subplot, respectively.

Normally, whenever you have plotted a function on a subplot and you try to plot another function, Matlab will erase the subplot and start over.  Often you will want to plot two signals on top of each other for comparison.  This can be done by using the 'hold', which toggles the hold property of a subplot on or off.  In this next example, the 2 original sinewaves are created again, this time using the built-in exponential function exp, the built-in function imag and Euler's relation.  The imag function just returns the imaginary part of a complex number. These statements accomplish the same thing that the sin function did earlier, and are only used to illustrate again that Matlab handles all of the complex arithmetic we need very naturally.  In this example, the two sinewaves are plotted on top of each other, and the sum is plotted again in its own subplot.  Notice that the plot command can also take a third argument that specifies the color and linestyle of the resulting plot.  There are many options here, and they can be viewed by typing help plot at the prompt.

% create the same sine waves using Euler's relations
s_3 = (exp(j*2*pi*f_1*t) - exp(-j*2*pi*f_1*t))/(2*j);
s_4 = imag(exp(j*2*pi*f_2*t));

% plot the 2 and 4 Hz waves together in the same panel
figure
subplot(2,1,1)
plot(t,s_3, 'b-')
hold on
plot(t, s_4, 'r--')
ylabel('Amplitude')

% again plot the sum in the bottom panel
subplot(2,1,2)
plot(t, s_3+s_4)
ylabel('Amplitude')
xlabel('Time (s)')

Basic Programming (For Loops)

Though we haven't mentioned much of this, Matlab is also actually a programming language with all of the usual iterative and conditional execution abilities.  Because it is matrix based, many operations that you would normally use a loop for (say, if you were programming in C) can be done much faster using Matlab's built-in matrix operations.  But, loops are sometimes unavoidable when you have repeated operations to perform on a list of parameters, and we will illustrate a simple one with an example here.  All of the commands given in this section can be found in the file sumsinplot.m, and can be executed in batch by typing sumsineplot at the command prompt.

By far, the most common looping apparatus (in Matlab, at least) is the for loop.  The basic  for loop has the following structure:

for variable = values
statements
end

where variable in this case is generally some sort of counter or indexing variable.  This is probably best explained through an illustration.  In this example, we will generate sinwaves with odd integers for frequencies (1, 3, 5, 7, 9, 11) and cumulatively sum them together. After each new sinewave is added to the others, the result is plotted in its own subplot.  To be explicit, a 1 Hz sinewave is generated and plotted.  Then a 3 Hz sinewave is generated, added to the 1 Hz sinewave and plotted.  A 5 Hz sinewave is generated, added to the sum of the 1st two signals and plotted, etc.  The only new things in this example are the use of the for loop, and the use of the zeros command.  The zeros(n,m) command returns a vector of dimension (n x m), initialized to all zeros.

%plot cumulatively summed sine waves with odd integer frequencies scaled by 1/f

>> t = 0:.001:1;        % independent (time) variable
>> A = 1;              % amplitude
>> f = 1:2:11;         % odd frequencies
>> s = zeros(1,101);   % empty 'signal' vector to start with

>> figure

% for each frequency, create the signal and add it into s(t)
>> for count=1:6
>>     s = s + A*sin(2*pi*f(count)*t)/f(count);
>>     subplot(6,1,count)
>>     plot(t,s);
>>     ylabel('Amplitude')
>> end

>> subplot(6,1,1)
>> title('Cumulatively summing sine waves')
>> subplot(6,1,6)
>> xlabel('Time (s)')

One more plotting example...
Just as one last example of how easy it is to do even 3-D plotting in Matlab, the file lenaex.m is provided, along with the 'Lena' test image.  If you have both this .m file and the image file (a .mat, Matlab data file) in the same directory and type lenaex at the prompt, this file will load the Lena image and produce the 3-D intensity mesh plot of the same image.  With the mesh plot active, type view(0, -90) to rotate the 3-D image so you are looking at it face-on.

crozell@rice.edu
8/26/2003