MATLAB on Athena (AC-71)

Getting Started

• matrix manipulation
• finding the roots of polynomials
• digital signal processing
• x-y and polar plotting
• 3-dimensional graphics

Starting a Session

  athena% mkdir ~/matlab

To actually use MATLAB, do the following:

  athena% add matlab
  athena% matlab

A new xterm window pops up (you are prompted for its location and size in the usual manner), and all appropriate environment variables are set in that window alone. The new xterm displays the MATLAB header and >> prompt. A graphics window also pops up as MATLAB starts up, but then disappears almost immediately; you have no control over this window and need not worry about its behavior. As you create graphics, they appear in separate windows. The graphics windows usually appear on top of the MATLAB xterm window and you will need to position the windows so that they don't overlap (this makes it easier to use them together).

MATLAB lives in the matlab locker on Athena. The main program and all of the functions for MATLAB are in specific subdirectories of the /mit/matlab directory. This locker is automatically attached whenever you execute add matlab unless it has already been attached during your login session.

When you are finished using MATLAB, type exit at the >> prompt; any graphics windows disappear and the athena% system prompt returns in the xterm from which you started MATLAB. Typing exit at the athena% prompt makes this xterm go away.

Matlab 6 introduced the Matlab Desktop, a graphical interface with additional tools; because it runs more slowly than the traditonal command-line interface, it is not currently on by default but you can use it by typing desktop at the MATLAB prompt, or start MATLAB by typing matlab -desktop.

Running a MATLAB Demo

  >> demo

This puts you into the MATLAB demo window. At the bottom left is a "Close" button, which closes the demonstration window. At the top, the menu bar has File, Window, and Help options. The File window allows you to open and close files, create new files, print demonstrations, and perform other file-related functions. Window allows you to switch between demo windows; Help uses Netscape to access MATLAB's graphical help capabilities.

A list of topics which have demonstrations will appear in the left-hand window; information on these topics appears in the upper right-hand window. In order to expand a topic in the left window, double-click on it and subtopics will appear below. When you click on one of these, a list of possible demonstrations to run in the lower right-hand window will appear. At this point, the button below this window changes to "Run (demonstration name)". Click on this to run the demonstration.

More Help With MATLAB

Online Help

To use command line help, you may first want to type more on at your MATLAB prompt. This will cause MATLAB to pause between each screen of text. Therefore, you can control your reading, rather than having the entire file scroll by. (Use the space bar to advance a page, RETURN to advance a line, "q" to exit from the item being displayed. Type 'help more' for more details.)

Typing help with no arguments at the MATLAB >> prompt displays a list of all primary help topics along with a short description for each one. Typing help directoryname displays a list of .m files in the directory, along with a brief description of each one if one has been provided, while typing 'what directoryname' displays all of the MATLAB-related files in a directory.

Typing help function displays the syntax for the function (i.e. what arguments it expects) and a short description of what that function does. For example, if you type help help at the MATLAB prompt, it will give you documentation on the help function.

If you think you are doing everything right, but MATLAB disagrees, try looking at help for the functions you are using. It may also be useful to verify the source of a function by typing 'which function -all'; this behaves similarly to the where command in UNIX, telling you what directory the function is located in.

If you don't know a function's name, you can try to find it using the 'lookfor' command (or the search feature in the Help Desk). This does a keyword search on the first comment line of each M-file accessible to MATLAB, and may take some time to finish. (The switch "-all" can be used to search through the entire first comment block, but this will lengthen the search.) For example:

  >> lookfor cartesian

  CART2POL Transform Cartesian to polar coordinates.
  CART2SPH Transform Cartesian to spherical coordinates.
  POL2CART Transform polar to Cartesian coordinates.
  SPH2CART Transform spherical to Cartesian coordinates.

When you write your own functions, you can also include help information for them. This can be very useful for other people using your function, or for your own use if you haven't used the function for a while. For more information on how to include help information for your own functions, see the section Creating Your Own Functions.

Hardcopy Documentation

• Using MATLAB
• Using MATLAB Graphics

You may purchase your own copies of the documention from the vendor; contact:

  The MathWorks, Inc.
  24 Prime Parkway
  Natick, MA  01760
  (508) 653-1415
  FAX:  (508) 653-2997
  E-mail:  info@mathworks.com

Matrix/Vector Operations

Creating and Working with Matrices

  variable = [value1-1  value1-2  value1-3 ... ;
  value2-1  value2-2 ...] 

  >> x = [1 2 3 4; 0 9 3 8]
  x =
     1     2     3     4
     0     9     3     8
  >>

To use complex numbers, enter them in the form a+bi, without spaces. You can also initialize matrices with these:

  >> x = [4+5i  2  4;  1  3+i  7]
  x =
     4.0000 + 5.0000i   2.0000             4.0000
     1.0000             3.0000 + 1.0000i   7.0000

Vectors and scalars are initialized the same way as matrices. It is important to note that MATLAB indexes matrices in the following manner:

  (1,1)  (1,2)  (1,3)  (1,4)
  (2,1)  (2,2)  (2,3)  (2,4)

If x is already defined as a vector of the form [val1 val2 val3 val4...] then you can define a new variable as a subset of x by using the index of the specific value in vector x. For example, if x is defined as [2 4 1 7], then:

  >> z = x(3)
  z =
      1

  >> y =  [ 1 2 3 4 5; 3 4 5 6 7]
  y =
       1     2     3     4     5
       3     4     5     6     7
  
  >> z  =  y(2,1)
  z =
       3

  >> z  =  (1:5)
  z =
       1     2     3     4     5

J:D:K steps from J to K in increments of D. For example:

  >> z = (1:3:7)
  z = 
       1     4     7
  >> z = (14:-2:5)
  z = 
       14    12    10    8     6

MATLAB has a variety of built-in functions to make it easier for you to construct matrices without having to enumerate all the elements. (The following examples show both vectors and matrices.)

The ones function creates a matrix whose elements are all ones. Typing ones(m,n) creates an m row by n column matrix of ones. To create a ones matrix that is the same size as an existing matric, you can use ones(size(X)). This does not affect the input argument. For example (this definition of x applies to subsequent examples in this section):

  >>  x = [1 2 3 4; 0 9 3 8]
  x =
       1     2     3     4
       0     9     3     8
  
  >>  y  =  ones(size(x))
  y =
       1     1     1     1
       1     1     1     1

The max and min functions return the largest and smallest values in a vector. For example (this definition of z applies to the following series of examples):

  >> z  =  [1  2  -9  3  -3  -5]
  z =
     1     2    -9     3    -3    -5
  
  >>  max(z) 
  ans =
       3

For example:

  >> [a b] = max(z)
  a =
       3
  b =
       4
  >> [a b] = max (x)
  a = 
       1     9     3     8
  b = 
       1     2     1     2  

where a is the maximum value of the vector and b is the index of that value. The MATLAB function min is exactly parallel to max:

  >>  min(z)
  ans = 
       -9  

  >>  sum(z)
  ans =
     -11

  >> w = magic(3);
  >> w
  
  w =
  
       8     1     6
       3     5     7
       4     9     2
  
  >> sum(w)
  
  ans =
  
      15    15    15
  
  >> sum(sum(w))
  
  ans =
  
      45

  >>  prod(z)
  ans  =
	-810

For matrices, prod(y) takes the product down the columns.

  >> prod(w)
  ans = 
        96    45    84

Often, it is useful to define a vector as a subunit of a previously defined vector. To do this, you can use the colon operator. For example, using the z defined above,

  >>  z
  z = 
       1     2    -9     3    -3    -5
  
  >>  y  =  z(2:5) 
  y =
       2    -9     3    -3

You can use subarrays in MATLAB, as well. A(J,:) specifies the Jth row of the matrix A. A(:,K) specifies the Kth column of the matrix A. Combining these, A(J-range,K-range) specifies a submatrix. So, you could specify a subset of y using the colon:

  >> y = [1 2 3 4 5; 3 4 5 6 7]
  y =
       1     2     3     4     5
       3     4     5     6     7
  >> z = y(1:2,2:3) 
  z =
       2     3
       4     5

The size function returns a two-element vector giving the dimensions of the matrix with which it was called. For example:

  >>  x = [1 2 3 4; 0 9 3 8]
  x =
       1     2     3     4
       0     9     3     8
  
  >>  y  =  size(x) 
  y =
      2     4

  >>  [m  n]  =  size(x)
  m =
	  2
  n =
	  4

  >>  length(x) 
  ans =
	    4

Basic Arithmetic

  +    addition
  -    subtraction
  *    multiplication
  /    division
  ^    exponentiation

The special operator ' (prime or apostrophe) takes the transposition of a matrix. For example:

  >> a = [1 2 3]
   
  a =
   
       1     2     3
   
  >> a'
   
  ans =
   
       1
       2
       3

For a matrix with complex entries, this takes the complex conjugate transpose. To take the transpose without the conjugate, use .'.

  >> b = [1 2 3] + i*[-4 3 2]

       1.0000 - 4.0000i     2.0000 + 3.0000i     3.0000 + 2.0000i

  >> b'

  ans = 
       1.0000 + 4.0000i
       2.0000 - 3.0000i
       3.0000 - 2.0000i

  >> b.'

  ans = 
       1.0000i - 4.0000i
       2.0000  + 3.0000i
       3.0000  + 2.0000i

Element-Wise Operations

  >>  w  =  x+y 
  w =
      6     8     5

  >>  w  =  x .* y 
  w =
     5    12     6

  >>  w  =  x .^ 2
  w =
     1     4     9

  >>  w  =  y ./ x 
  w =
     5.0000    3.0000    0.6667

  >>  y  =  abs(x)
  y =
     2   4   5   3

  >>  phase  =  angle(x)
  phase=
	0   -3.1416   -0.9273   -1.5708

  >>  x = [4   -9    i    2-2i];
  >>  y  =  sqrt(x)
  y =
     2.0000   0 + 3.0000i   0.7071 + 0.7071i   1.5538 - 0.6436i

MATLAB has several operators that round fractional numbers to integers. The round function rounds its elements to the nearest integer. The fix function rounds its elements to the nearest integer towards zero, e.g. rounds ``down'' for positive numbers, and ``up'' for negative numbers. The floor function rounds its elements to the nearest integer towards negative infinity, e.g. ``down.'' The ceil (short for ceiling) function rounds its elements to the nearest integer towards positive infinity, e.g. ``up.''

All of these commands are defined to work element-wise on matrices and vectors. If you apply one of them to a complex number, it will round both the real and imaginary part in the manner indicated. For example:

  >>  ceil(3.1+2.4i)
  ans=
      4.0000 + 3.0000i

  >> x = [8  5  11];
  >> y = [6  5  3];
  >>  r  =  rem(x,y)
  r=
    2     0     2

  >> sin (pi/2)
  ans = 
        1

Note that the functions are also defined on complex arguments. For example, cos(x+iy) = cos(x)cosh(y) - i sin(x)sinh(y). The inverse trig functions (acos, asin and atan) are also defined to operate element-wise across matrices. Again, these are defined on complex numbers, which can lead to problems for the incautious user. The arctangent is defined to return angles between pi/2 and -pi/2.

In addition to the primary interval arctangent discussed above, MATLAB has a full four-quadrant arctangent operator, atan2. atan2(y,x) returns the angle between -pi and pi whose tangent is the real part of y/x. If x and y are vectors, atan2(y,x) divides y by x element-wise, then returns a vector in which each element is the four-quadrant arctangent of corresponding element of the y/x vector.

MATLAB also includes functions for exponentials and logarithms. The exp operator computes e to the power of its argument. This works element-wise, and on complex numbers. The pi function returns the floating point number nearest the value of pi. So, to generate the complex exponential with a frequency of pi/4, we could type:

  >>  n  =  0:7;
  >>  s  =  exp(i*(pi/4)*n)
  s =
  
    Columns 1 through 4
     1.0000             0.7071 + 0.7071i   0.0000 + 1.0000i  -0.7071 + 0.7071i
  
    Columns 5 through 8
    -1.0000 + 0.0000i  -0.7071 - 0.7071i  -0.0000 - 1.0000i   0.7071 - 0.7071i

Logical Operations

  >>  x  =  [1 0 2 4]  &  [0 0 1 i]
  x =
       0    0    1    1
  >>  x  =  [1 0 2 4]  |  [0 0 1 i]
  x =
       1    0    1    1

You can also compare two vectors element-wise with any of six basic relational operators:

For example:

  >>  x  =  [1 2 3 4 5]  <=  [5 4 3 2 1]
  x =
	1    1    1    0    0

Control Structures

  for s = 1:4
	 s
  end

  s =
       1
  s =
       2
  s =
       3
  s =
       4

  for m = 1:3
      for n = 1:3
	 x (m,n) = m + n*i;
      end
  end

   x =
  
	1.0000 + 1.0000i   1.0000 + 2.0000i   1.0000 + 3.0000i
	2.0000 + 1.0000i   2.0000 + 2.0000i   2.0000 + 3.0000i
	3.0000 + 1.0000i   3.0000 + 2.0000i   3.0000 + 3.0000i

The if command lets you have programs that make decisions about what commands to execute. The basic command looks like:

  if a > 0
	  x = a^2;
  end

  if a > 0
	 x = a^2;
  else
	 x = - a^2;
  end

  if a > 0
	   x = a^2;
  elseif a == 0,
	   x = i;
  else
	   x = - a^2;
  end

The third major control structure is the while command. The while command allows you to execute a group of commands until some condition is no longer true. These commands appear between the while and its matching end statement. For example, if you want to start x at 2 and keep squaring x until it is greater than one million, you would type:

  x = 2
  while x < 1000000
	  x = x^2;
  end

The pause and keyboard commands can be useful in functions that you write yourself. The pause command causes MATLAB to wait for a key to be pressed before continuing. The keyboard command passes control to the keyboard, indicated by a the prompt K>>. You can examine or change variables, or issue any MATLAB command. Terminate keyboard mode by executing the command return at the K>> prompt.

Sometimes you will want to terminate a for or while loop early. You can use the break command to jump out of a for or while command. For example, you could rewrite the while example above using break:

  while 1
	  if x > 1000000
		  break;
	  end
	  x = x^2;
  end

Selective Indexing

  >> x(x<0) = - x(x<0)

  >> x = [-3 -2 0 2 4]
  x =
      -3    -2    0    2    4
  >> x(x<0) = - x(x<0)
  x =
       3     2    0    2     4

You can also perform operations on a vector conditionally based upon the value of the corresponding element of another vector. For example, if you want to divide two vectors element-wise, you have to worry about what happens if the denominator vector includes zeros. One way to deal with this is shown below.

  >> x = [3 2 0 2 4]
   x =
	3    2    0    2    4
   >> y = [1 1 1 1 1]
   y =
	1    1    1    1    1
   >> q = zeros(1,length(y))
   q =
	0    0    0    0    0
   >> q(x~=0) = y(x~=0) ./ x(x~=0)
   q =
      0.3333    0.5000      0     0.5000    0.2500

  >> q((x<=3) & (q<=0.4)) = q((x<=3) & (q<=0.4)) + 14
  q =
     14.3333   0.5000     14.0000     0.5000    0.2500

Polynomial Operations

  >>  y  =  [1  -5  6];

  >>  roots(y)
  ans =
       3  
       2

You can multiply two polynomials using the conv function. The convolution of the coefficient vectors is equivalent to multiplying the polynomials. For example, if we define w = 3x^2 - 4x -1 (so the vector w = [3 -4 -1]) and use the y given above:

  >>  z  =  conv(w,y)
  z =
  
	3   -19    37   -19    -6

  >>  polyval(y,1) 
  ans =
  
       2

Signal Processing Functions

Libraries and Search Paths

The list you get with the path command is also MATLAB's current directory search path. MATLAB's search rules are as follows; when you enter a name, MATLAB:

1. looks to see if the name is a variable.
2. looks for it as a built-in function.
3. searches in the current directory for the related .m file.
4. searches the directories specified by path for the .m file.

Graphics

The following are some of the large number of new plot types that have been added to MATLAB 4.0:

• 3-D shaded color surface graphs
• 3-D contour plots
• 3-D line trajectories
• 3-D volumetric "slice" plots
• 3-D axes on mesh and surface plots
• Combination surface and contour plots
• Image display
• Lighting and rendering models

Plotting Individual Graphs

  >>  n  =  0:11;
  >>  y  =  sin((pi/6)*n);
  >>  plot(n,y)

  >>  plot(y)

You can also change the type of line used to connect the points by including a third argument specifying line type. The format for this is plot(x,y,line-type). The line types available are:

  '-'    solid line (default)
  '--'   dashed line
  ':'    dotted line
  '-.'   line of alternating dots and dashes

  >>  plot(n,y,'o')

  plot(x1,y1,x2,y2)

  plot(x1,y1,'line-type1',x2,y2,'line-type2')

  ----------------------------------------
  Command     X-Axis Scale    Y-Axis Scale
  ----------------------------------------
  loglog      logarithmic     logarithmic

  semilogy    linear          logarithmic

  semilogx    logarithmic     linear
  ----------------------------------------

  >>  title('MATLAB Graph #1') 

  >>  xlabel('This is the x-axis')
  >>  ylabel('This is the y-axis')

  a  =  axis

The elements of the vector you use to set the values of the axes should be your choices for the x- and y-axis limits, in the same order as specified above ([x-min x-max y-min y-max]). So, if you type

  >>  axis([-10 10 -5 5])

The hold command will keep the current plot and axes even if you plot another graph. The new graph will just be put on the current axes (as much as fits). Typing hold a second time will toggle the hold off again, so the screen will clear and rescale for the next graph.

Aspect Ratio Control

Plotting Multiple Graphs

  >> subplot(xyn)

  >> subplot(i>x,y,n)

		       |
		    1  |  2
		 ------+------
		    3  |  4
		       |

  >>  print -Pprintername

  >>  print -Plinus 

  >> print -ddevice filename

  function  function-name(argument1, argument2,...)

  function stars(t)
  %STARS(T)       draws stars with parameter t
  n = t * 50;
  plot(rand(1,n), rand(1,n),'.');
  %that line plots n random points
  title('My God, Look at all the Stars!');
  %label the graph

  >>  help stars
  STARS(T)       draws stars with parameter t

  >> clear function-name

  function variable = function-name(argument1,
  argument2,...)

  function y = fliplr(x)
  %FLIPLR(X) returns X with row preserved and columns flipped
  %in the left/right direction.
   
  %  X = 1 2 3     becomes  3 2 1
  %      4 5 6              6 5 4
   
  [m,n] = size(x);
  y = x(:,n:-1:1);

  function [factors, times] = primefact(n)
  %[FACTORS TIMES] = PRIMEFACT(N) find prime factors of n
  
  primes = [2 3 5 7];
  
  for i = 1:4
     temp = n;
       if ( rem(temp,primes(i)) == 0)
	   factors = [factors primes(i)];
	   times = [times 0];
	       while (rem(temp,primes(i)) == 0)
		 temp = temp/primes(i);
		 times(length(times)) = times(length(times))+1;
	       end
       end
  end

  >> [a b] = primefact(180)
  a =
       2    3    5
  b =
       2    2    1

   function hippo = rhino(a,b,c,d)

  clear script-name

  >> save filename

  >> save  filename  x  y 

  >> load filename

   load filename

  >> whos  
      Name        Size       Elements     Bytes    Density   Complex
   
	 A       3 by 3             9        72       Full      No 
	 B       3 by 3             9        72       Full      No 
	 C       3 by 3             9        72       Full      No 
	 I       3 by 3             9        72       Full      No 
	 X       3 by 3             9        72       Full      No
	 a       1 by 9             9        72       Full      No   
       ans       3 by 1             3        24       Full      No 
	 b       1 by 9             9        72       Full      No 
	 p       1 by 4             4        32       Full      No 
	 q       1 by 7             7        56       Full      No 
	 r       1 by 10           10        80       Full      No 
  Grand total is 87 elements using 696 byte

  >> whos  
      Name        Size       Elements     Bytes    Density   Complex
   
	 A    4253 by 4253      28831    362984     0.0016      No 

  cd        change directory (same as chdir)
  delete    delete file (same as rm)
  dir       list (same as ls)
  ls        list (same as dir)
  type      display contents of a file (same as cat)
  unix      execute operating system command and return result to MATLAB
  !         precedes operating system command called within MATLAB

  >> [s,date] = unix('date')
   
  s =
   
       0
   
   
  date =
   
  Wed Oct 27 11:05:12 EDT 1993

  >> simulink

  >> demo simulink