MATH2070: LAB 2: Beginning Matlab

Introduction	Exercise 1
Matlab files	Exercise 2
Variables	Exercise 3
Variables are Matrices	Exercise 4
Vector Operations	Exercise 5
Flow control	Exercise 6
M-files and graphics	Exercise 7

Introduction

In the last lab, we learned how to start up Matlab and a little bit about using Matlab. I asked you to read a brief excerpt from the Matlab ``Getting Started'' manual that is available on the Web from The Mathworks. This lab is intended as an introduction to using the Matlab language as a programming language. We will not be concerned with many of the details of this language, we will focus on those aspects of the language that make it ideal for numerical calculations.

But Matlab is a programming language and it is important to learn the basics of good programming so that you will be able to function as professionals using Matlab.

This lab will take two sessions. If you print it, you may find the Adobe pdf version more appropriate.

Matlab files

The best way to use Matlab is to use its scripting facility. With sequences of Matlab commands contained in files, it is easy to see what calculations were done to produce a certain result, and it is easy to show that the correct values were used in producing a graph. It is terribly embarrassing to produce a very nice plot that you show to your advisor only to discover later that you cannot reproduce it or anything like it for similar conditions or parameters. When the commands are in clear text files, with easily read, well-commented code, you have a very good idea of how a particular result was obtained. And you will be able to reproduce it and similar calculations as often as you please.

The Matlab comment character is a percent sign (%. That is, lines starting with % are not read as Matlab commands and can contain any text. Similarly, any text on a line following a % can contain textual comments and not Matlab commands.

A Matlab script file is a text file with the extension .m. Matlab script files should always start off with comments that identify the author, the date, and a brief description of the intent of the calculation that the file performs. Matlab script files are invoked by typing their names at the Matlab command line or by using their names inside another Matlab file.

Matlab function files are also text files with the extension .m, but the first non-comment line must start with the word function and be of the form

function output variable = function name (parameters)

This defining line is called the ``signature'' of the function. The output variable and parameters can be missing. The name of the function must be the same as the file name. The lines following the function should always contain comments repeating the signature of the function and identifying the author, the date, a brief description of the intent of the calculation the file performs, and brief descriptions of the input and output variables. Part of the first of these lines is displayed in the ``Current directory'' windowpane, and the lines themselves comprise the response to the Matlab command help <function>.

The key difference between function and script files is that functions are intended to be used repetitively. They can accept parameters and variables used inside a function are invisible outside the function. When I am working on a task, I often start out using script files. As I discover just what tasks are repetitive or when I start to need the same calculation repeated for different parameters, or when I have many intermediate variables that might have the same names as variables in other parts of the calculation, I switch to function files. In these labs, I will specify function file or script file when it is important, and you are free to use what you like when I do not specify.

Because function files are intended to be used multiple times, it is a bad idea to have them print or plot things. Imagine what happens if you have a function that prints just one line of information that you think might be useful, and you put it into a loop that is executed a thousand times. Do you plan to read those lines?

Matlab commands are sometimes terminated with a semicolon (;) and sometimes not. The difference is that the result of a calculation is printed to the screen when there is no semicolon but no printing is done when there is a semicolon. It is a good idea to put semicolons at the ends of all calculational lines in a function file.

Matlab also supports data files. The Matlab save command will cause every variable that Matlab currently knows about to be saved in a file called ``matlab.mat''. You can also name the file with the command save filename that will put everything into a file named ``filename.mat''. This command has many other options, and you can find more about it using the help facility. The inverse of the save command is load.

Note: Matlab function names are case-sensitive. This means that the function cos is different from Cos, coS, and COS. File names in Microsoft operating systems, however, are not strictly case sensitive. To avoid confusion for those students who might be using Matlab on a Microsoft system, we will only use lower-case names for Matlab function and script files.

Variables

Matlab uses variable names to represent data. A variable name represents a matrix containing complex double-precision data. Of course, if you simply tell Matlab x=1, Matlab will understand that you mean a $1\times1$ matrix and it is smart enough to print x out without its decimal and imaginary parts, but make no mistake: they are there. And x can just as easily turn into a matrix.

A variable can represent some important value in a program, or it can represent some sort of dummy or temporary value. Important quantities should be given names longer than a few letters, and the names should indicate the meaning of the quantity. For example, if you were using Matlab to generate a matrix containing a table of squares of numbers, you might name the table tableOfSquares. (The rule I am using here is that the first part of the variable name should be a noun and it should be lower case. Modifying words follow with upper case letters separating the words. This rule comes from the officially recommended naming of Java variables.)

Once you have used a variable name, it is bad practice to re-use it to mean something else. It is sometimes necessary to do so, however, and the statement

clear firstVariable secondVariable

should be used to clear the two variables firstVariable and secondVariable before they are re-used. This same command is critical if you re-use a variable name but intend it to have smaller dimensions.

Matlab has a few reserved variable names. You should not use these variables in your m-files. If you do use such variables as i or pi, they will lose their special meaning until you clear them. Reserved names include

ans: The result of the previous calculation.

computer: The type of computer you are on.

eps: The smallest positive number $\epsilon$ that can be represented on this computer and that satisfies the expression $1+\epsilon>1$.

i, j: The imaginary unit ($\sqrt{-1}$).

inf: Infinity ($\infty$). This will be the result of dividing 1 by 0.

NaN: ``Not a number.'' This will be the result of dividing 0 by 0, inf by inf, etc.

pi: $\pi$

realmax, realmin: The largest and smallest real numbers that can be represented on this computer.

version: The version of Matlab you are running.

Exercise 1: Start up Matlab and use it to answer the following questions.

1. What are the values of the reserved variables pi, eps, realmax, and realmin?
2. Choose a value and set the variable x to that value.
3. What is the square of x? Its cube?
4. Choose an angle $\theta$ and set the variable theta to its value (a number).
5. What is $\sin\theta$? $\cos\theta$? Is the angle $\theta$ interpreted as degrees or radians?
6. Use the save command to save all your variables. Check your ``Current Directory'' to see that you have created the file matlab.mat.
7. Use the clear command. Check that there are no variables left in the ``current workspace'' (windowpane is empty).
8. Restore all the variables with load and check that the variables have been restored to the ``Current workspace'' windowpane.

Variables are matrices

We said that Matlab treats all its variables as though they were matrices. Important subclasses of matrices include row vectors (matrices with a single row and possibly several columns) and column vectors (matrices with a single column and possibly several rows). One important thing to remember is that you don't have to declare the size of your variable; Matlab decides how big the variable is when you try to put a value in it. The easiest way to define a row vector is to list its values inside of square brackets, and separated by spaces or commas:

rowVector = [ 0, 1, 3, 6, 10 ]

The easiest way to define a column vector is to list its values inside of square brackets, separated by semicolons or line breaks.

columnVector1 = [ 0; 1; 3; 6; 10 ]
columnVector2 = [ 0
                  1
                  9
                  36
                  100 ]

(It is not necessary to line the entries up as I have done, but it makes it look nicer.)

Matlab has a special notation for generating a set of equally spaced values, which can be useful for plotting and other tasks. The format is:

start : increment : finish

or

start : finish

in which case the increment is understood to be 1. Both of these expressions result in row vectors. So we could define the even values from 10 to 20 by:

evens = 10 : 2 : 20

Sometimes, you'd prefer to specify the number of items in the list, rather than their spacing. In that case, you can use the linspace function, which has the form

linspace( firstValue, lastValue, numberOfValues )

in which case we could generate six even numbers with the command:

evens = linspace ( 10, 20, 6 )

or a large number of evenly-spaced points in the interval [10,20] with

points = linspace ( 10, 20, 23 )

Another nice thing about Matlab vector variables is that they are flexible. If you decide you want to add another entry to a vector, it's very easy to do so. To add the value 22 to the end of our evens vector:

evens = [ evens, 22 ]

and you could just as easily have inserted a value 8 before the other entries, as well.

Even though the number of elements in a vector can change, Matlab always knows how many there are. You can request this value at any time by using the length function. For instance,

length ( evens )

should yield the value 7 (the 6 original values of 10, 12, ... 20, plus the value 22 tacked on later). In the case of matrices with more than one nontrivial dimension, the length function returns the total number of entries. Use the size function in this case. For example, since evens is a row vector, size( evens, 1)=1 and size( evens, 2)=7.

To specify an individual entry, you need to use index notation, which uses round parentheses enclosing the index of an entry. The first element of an array has index 1 (as in Fortran, but not C). Thus, if I want to alter the third element of evens, I could say

evens(3) = 7

Exercise 2:

1. Use the linspace function to create a row vector called meshPoints containing exactly 100 elements with values evenly spaced between -1 and 1.
2. What expression will yield the value of the $37^{\mbox{th}}$ element of meshPoints? What is this value?
3. Double-click on the variable meshPoints in the ``Current workspace'' windowpane to view it as a vector and confirm its length is 100.
4. Produce a plot of a sinusoid on the interval $[-1,1]$ using the command

   plot(meshPoints,sin(2*pi*meshPoints))
   

   Please save (export) this plot as a jpeg (.jpg) file and include it with your summary.
5. Create a file named exer2.m (you can use the Matlab command edit, type the above commands into the window and use ``Save as'' to give it a name). The first lines of the file should be the following:

   % Lab 2, exercise 2
   % A sample script file.
   % Your name and the date
   

   followed by your name and the date. Follow the header comments with the commands containing exactly the commands you used in the earlier parts of this exercise. Test your script by using clear to clear your results and then execute the script from the command line by typing exer2, by using the ``Run'' button (looks like a sheet of paper with an arrow pointing down) at the top of the edit window, or by using Debug$\rightarrow$Run from the edit window menus.

Vector Operations

Matlab provides a large assembly of tools for matrix and vector manipulation. We will investigate a few of these by trying them out.

Exercise 3: Define the following vectors and matrices:

rowVec1 = [ -1 -4 -9]
colVec1 = [ 2
            4
            8 ]
mat1 = [ 1  3  5
         7  9  2
         4  6  8 ]

1. You can multiply vectors by constants. Compute

   colVec2 = (pi/4) * colVec1
   

2. The cosine function can be applied to a vector to yield a vector of cosines. Compute

   colVec2 = cos( colVec2 )
   

   Note that the values of colVec2 have been overwritten. Are these the values you expect?
3. You can add vectors. Compute

   colVec3 = colVec1 + colVec2
   

4. Matlab will not allow you to do illegal operations! Try to compute

   illegal = colVec1 + rowVec1;
   

   Look carefully at the error message. You must recognize from the message what went wrong when you see it in the future.
5. You can do row-column matrix multiplication. Compute

   colvec4 = mat1 * colVec1
   

6. A single quote following a matrix or vector indicates a transpose.

   mat1Transpose = mat1'
   rowVec2 = colVec3'
   

   Warning: The single quote really means the complex-conjugate transpose (or Hermitian adjoint). If you want a true transpose applied to a complex matrix you must use ``.'''.
7. Transposes allow the usual operations. You might find ${\bf u}^T{\bf v}$ a useful expression to compute the dot (inner) product ${\bf u}\cdot{\bf v}$ (although there is a dot function in Matlab).

   mat2 = mat1 * mat1'     % symmetric matrix
   rowVec3 = rowVec1 * mat1
   dotProduct = colVec3' * colVec1
   euclideanNorm = sqrt(colVec2' * colVec2)
   

8. Matrix operations such as determinant and trace are available, too.

   determinant = det( mat1 )
   tr = trace( mat1 )
   

9. You can pick certain elements out of a vector, too. Find the smallest element in a vector rowVec1.

   min(rowVec1)
   

10. The min and max functions work along one dimension at a time. They produce vectors when applied to matrices.

    max(mat1)
    

11. You can compose vector and matrix functions. For example, use the following expression to compute the max norm of a vector.

    max(abs(rowVec1))
    

12. How would you find the single smallest element of a matrix?
13. As you know, a magic square is a matrix all of whose row sums, column sums and the sums of the two diagonals are the same. (One diagonal of a matrix goes from the top left to the bottom right, the other diagonal goes from top right to bottom left.) Show by direct computation that if

    A=magic(100);   % please do not print all 10,000 entries.
    

    then the largest and smallest row sums, the largest and smallest column sums, and the sums of the two diagonals are all the same.

    Hints:

    • Use the Matlab min and max functions.
    • Recall that sum applied to a matrix yields a row vector whose values are the sums of the columns.
    • The Matlib function diag extracts the diagonal of a matrix, and the composed function sum(diag(fliplr(A))) computes the sum of the other diagonal.
14. Suppose we want a table of integers from 0 to 10, their squares and cubes. We could start with

    integers = 0 : 10
    

    but now we'll get an error when we try to multiply the entries of integers by themselves.

    squareIntegers = integers * integers
    

    Realize that Matlab deals with vectors, and the default multiplication operation with vectors is vector multiplication. In order to do element-by-element multiplication, we need to place a period in front of the operator:

    squareIntegers = integers .* integers
    

    Now we can define cubeIntegers and fourthIntegers in a similar way.

            
    cubeIntegers = squareIntegers .* integers
    fourthIntegers = squareIntegers .* squareIntegers
    

    Finally, we would like to print them out as a table. integers, squareIntegers, etc. are row vectors, so make a matrix whose columns consist of these vectors and allow Matlab to print out the whole matrix at once.

    tableOfPowers=[integers', squareIntegers', cubeIntegers', fourthIntegers']
    

15. Watch out when you use vectors. The multiplication, division and exponentiation operators all have two possible forms, depending on whether you want to operate on the arrays, or on the elements in the arrays. In all these cases, you need to use the period notation to force elementwise operations. Compute squareIntegers alternatively using the exponentiation operator as:

    squareIntegers = integers .^ 2
    

    These problems never come up with addition or subtraction; nor do they occur with division or multiplication by a scalar.
16. The index notation can also be used to refer to a subset of elements of the array. With the start:increment:finish notation, we can refer to a range of indices. Two-dimensional vectors and matrices can be constructed by leaving out some elements of our three-dimensional ones. For example, submatrices an be constructed from tableOfPowers. (The end function in Matlab means the last value of that dimension.)

    tableOfCubes = tableOfPowers(:,[1,3])
    tableOfOddCubes = tableOfPowers(2:2:end,[1,3])
    tableOfEvenFourths = tableOfPowers(1:2:end,1:3:4)
    

17. The Matlab function magic(n) returns an n$\times$n magic square. Use it to construct a $10\times10$ matrix.

    A = magic(10)
    

    What commands would be needed to generate the four $5\times5$ matrices in the upper left quarter, the upper right quarter, the lower left quarter, and the lower right quarter of A?

Flow control

It is critical to be able to ask questions and to perform repetitive calculations in m-files. These topics are examples of ``flow control'' constructs in programming languages. Matlab provides two basic looping (repetition) constructs: for and while, and the if construct for asking questions. These statements each surround several Matlab statements with for, while or if at the top and end at the bottom.

Note: It is an excellent idea to indent the statements between the for, while, or if lines and the end line. This indentation strategy makes code immensely more readable. Your m-files will be expected to follow this convention.

The syntax of a for loop is

for control-variable=start : increment : end

    Matlab statement ...

    ...

end

The syntax of a while loop is

Matlab statement initializing a control variable

while logical condition involving the control variable

    Matlab statement ...

    ...

    Matlab statement changing the control variable

end

The syntax of a simple if statement is

if logical condition

    Matlab statement ...

    ...

end

The syntax of a compound if statement is

if logical condition

    Matlab statement ...

    ...

elseif logical condition

    ...

else

    ...

end

Note that elseif is one word! Using two words else if changes the statement into two nested if statements with possibly a very different meaning, and a different number of end statements.

Exercise 4: The trapezoid rule for the approximate value of the integral of $e^x$ on the interval $[x_0,x_1]$ can be written as

$$\int_{x_0}^{x_1}e^xdx\approx \frac{h}2e^{x_0} + h\sum_{k=2}^{N-1}e^{x_k}+\frac{h}2e^{x_N}$$

where $h=1/(N-1)$ and $x_k=0,k,2k,\ldots,1$.

The following Matlab code computes the trapezoid rule for the case that $N=10$, $x_0=0$ and $x_1=1$.

% Use the trapezoid rule to approximate the integral from 0 to 1
% of exp(x), using N (=10) intervals
% Your name and the date
N=10;
h=1/(N-1);
x=-h;   % look at this trick
approxIntegral=0.;
for k=1:N
  % compute current x value
  x=x+h;

  % add the terms up
  if k==1 | k==N
    approxIntegral=approxIntegral+(h/2)*exp(x);   % ends of interval
  else
    approxIntegral=approxIntegral+h*exp(x);       % middle of interval
  end
end

1. Use cut-and-paste to put the code into Matlab and execute it. Is the final value for approxIntegral nearly equal to $e^1-1$? (You can get the value of a variable by simply typing its name at the command prompt.)
2. Notice the indentation. Typically, statements inside for loops and if tests are indented for readability. (There isn't much to be gained by indentation when you are typing at the command line, but when you put commands in a file you should always use indentation.)
3. What is the sequence of values taken on by the variable x?
4. How many times is the following statement executed?

     approxIntegral=approxIntegral+(h/2)*exp(x);   % ends of interval
   

5. How many times is the following statement executed?

     approxIntegral=approxIntegral+h*exp(x);       % middle of interval
   

M-files and graphics

If you have to type everything at the command line, you will not get very far. You need some sort of scripting capability to save the trouble of typing, to make editing easier, and to provide a record of what you have done. You also need the capability of making functions or your scripts will become too long to maintain. In this section we will consider first a script file and later a function m-file. We will be using graphics in the script file, so you can pick up how graphics can be used in our work.

The Fourier series for the function $y=x^3$ on the interval $-1\le x\le 1$ is

$$y=2\sum_{k=1}^\infty (-1)^{k+1}\left (\frac{\pi^2}{k}-\frac{6}{k^3}\right)\sin kx.$$ (1)

We are going to look at how this series converges.

Exercise 5: Copy and paste the following text into a file named exer5.m and then answer the questions about the code.

% compute NTERMS terms of the Fourier Series for y=x^3
% plot the result using NPOINTS points from -1 to 1.
% Your name and the date
NTERMS=10;
NPOINTS=300;
x=linspace(-1,1,NPOINTS);
y=zeros(size(x));
for k=1:NTERMS
  y=y-2*(-1)^k*(pi^2/k-6/k^3)*sin(k*x);
end
plot(x,y);
hold on
plot(x,x.^3,'g');
axis([-1,1,-2,2]);
hold off

It is always good programming practice to define constants symbolically at the beginning of a program and then to use the symbols within the program. Sometimes these special constants are called ``magic numbers.'' By convention, symbolic constants are named using all upper case.

1. Add your name and the date to the comments at the beginning of the file.
2. How is the Matlab variable x related to the dummy variable $x$ in Equation (1)? (Please use no more than one sentence for the answer.)
3. How is the Matlab statement that begins y=y... related to the summation in Equation (1)? (Please use no more than one sentence for the answer.)
4. In your own words, what does the line

   y=zeros(size(x));
   

   do? You can use Matlab help for zeros and size for more information.
5. Execute the script by typing its name exer5 at the command line, or by using the ``Run'' button or Debug$\rightarrow$Run menu choice on the ``Edit'' window. You should see a plot of two lines, one representing a partial sum of the series and the green line a plot of $x^3$, the limit of the partial sums. You do not have to send me this plot.
6. What would happen if the two lines hold on and hold off were omitted?

   Note: The command hold is actually a ``toggle.'' Each time it is used, it switches from ``on'' to ``off'' or from ``off'' to ``on.'' Using it that way is easier but you have to remember which state you are in.

In the following exercise you are going to modify the calculation so that it continues so long as the difference between the partial sum and the function $y=x^3$ is pretty small, say 0.1. The while statement is designed for this case. It would be used in the following way. (The ellipses represent lines of code that are unchanged from above.)

TOLERANCE=0.1;    % the chosen tolerance value
...
k=0;
difference=TOLERANCE+1;  % bigger than TOLERANCE
while difference > TOLERANCE
  k = k + 1;
  ...
  difference = max( abs( x.^3 - y ) );
end
disp( strcat('Number of iterations =',num2str(k)) )

Exercise 6:

1. Copy the file exer5.m to a new file called exer6.m. Change the comments at the beginning of the file to reflect the objective of this lab.
2. Modify exer6.m to use the while statement, according to the recipe given above.
3. What is the purpose of the statement

   difference=TOLERANCE+1;
   

4. What is the purpose of the statement

   k = k + 1;
   

5. Try the script to see how it works. How many iterations are required? Hint: If you try this script and it does not quit (it stays ``busy'') you can interrupt the calculation by holding the Control key (``CTRL'') and pressing ``C''.

The next task is to make a function m-file out of exer6.m in such a way that it takes as argument the desired tolerance and returns the number of iterations required to meet that tolerance.

Exercise 7:

1. Copy the file exer6.m to a new file called exer7.m. Turn it into a function m-file by placing the signature line first and adding a comment for its usage

   function k = exer7( tolerance )
   % k = exer7( tolerance )
   % more comments
   % Your name and the date
   

2. Replace the upper-case TOLERANCE with a lower-case tolerance because it no longer is a constant, and throw away the line giving it a value.
3. Note that the function name must agree with the file name. Add comments just after the signature and usage lines to indicate what the function does.
4. Delete the lines that create the plot and print (disp(...)) so that the function does its work silently.
5. Invoke this function from the Matlab command line by choosing a tolerance and calling the function. Matlab will print the result:

   exer7(0.1)
   

   and it will assign the value if it is invoked on the right of an equal sign:

   numItsRequired=exer7(0.1)
   

6. Use the command help exer7 to display your help comments. Make sure they describe the purpose of the function.
7. How many iterations are required for a tolerance of 0.1? For a tolerance of 0.05? For a tolerance of 0.025?

Back to MATH2070 page.