An Introduction to MATLAB

MATLAB is a environment for scientific computing that is ideal for computations that require extensive use of arrays and graphical analysis of data.

Matlab basics

• It is a interpreted language (no compiler); scripts can be saved as .m files
• Array indices begin with 1 (compare to 0 in C or Java)
• Arrays are passed by value to functions (no pointers)
• Array elements are accessed with the format A(1,2) (compare to the format A[0][1] in C or Java)
• Powerful matrix mathematical functions are built-in (e.g., \ for Gaussian elimination or least-squares solution methods for linear systems)

To start Matlab on the University of Maryland's glue network and perform some basic operations, try

:~: tap matlab :~: matlab < M A T L A B > Copyright 1984-2001 The MathWorks, Inc. Version 6.1.0.450 Release 12.1 May 18 2001 To get started, type one of these: helpwin, helpdesk, or demo. For product information, type tour or visit www.mathworks.com. >> >> % this is a comment >>

where :~: is the unix shell prompt and >> is the MATLAB environment prompt. At this point, MATLAB is ready to begin a computational session. Hitting the return key generates a MATLAB prompt on a new line; we will make extensive use of MATLAB comments which are found after the % character.

MATLAB and the file system

It is important to understand the relationship between the MATLAB operating environment and your computer's file system stucture because

• This will simplify organizing your work
• Object-oriented programming in MATLAB is implemented by defining object classes through user-created directories
• Directory structures can be navigated through unix-like commands.

Try the following commands on your computer:

>> pwd % present working directory >> ls % list directory contents >> mkdir newdir % make a new directory (folder) named newdir >> cd newdir % change directories to newdir

Data types

The default data type in MATLAB is a double-precision array. While this data type tends to be used most often in computations, several other data types also are important:

>> a = 2 % a scalar double a = 2 >> b = [ 2, 3] % a 1 by 2 array b = 2 3 >> s = 'a character string' s = a character string >> c = {'elements', 'in a cell array', 2} c = 'elements' 'in a cell array' [2] >> t.a = 1 t = a: 1 >> t.b = 'a structure' t = a: 1 b: 'a structure' >> class(t) % returns the data type ans = struct

Arrays

Arrays are defined and accessed based on the following concepts:

• Array indices begin with 1
• Column elements are separated by a comma (,) and row elements are separated by a semicolon (;) when arrays are defined
• Arrays must have a rectangular shape
• When defined, array elements are contained between the [ and ] symbols
• The element in row i and column j of matrix A (A_{i, j}) is accessed by A(i,j)
• A sequential list of elements can be generated by the colon (:) operator using the following form: initial value : increment : final value

  Now consider some basic Matlab operations/functions:

  >> a = [1, 2, 3] % row array >> b = [1; 2; 3] % column array >> c = a' % transpose operation >> a(1,2) % 1st row, 2nd column element >> A = [1, 2; 3, 4] >> A' % transpose operation >> A % echo A -- note previous ' operation had no effect >> who % show defined variables >> clear, who

  Array operations

  The arithmetic operations +, -, /, and * by default correspond to true matrix computations.

  • A*B is the matrix product of A and B
  • A.*B is the element-by element operation
  • There is no .+ operation because the + operation is by default element-by-element

  Now consider some basic Matlab operations/functions:

  >> a = [1:6] >> x = [1:0.1:3]' >> y = sin(2*pi*x) % an example of a scalar function operating on a vector >> plot(x,y) >> y = x^2 % won't work! >> y = x.^2 % term-by-term square >> plot(x,y) >> clear >> a = [1:4]' >> b = [2:5]' >> c = a*b % arrays are wrong size >> c = a'*b % the dot (inner product) >> c = a.*b % term-by-term product

  Script files

  Using a text editor, create a file called CpAir.m with the following text

  % Heat capacity of air in J/(mol K), where T is in K. The % equation is valid only in the range 273 K < T < 1800 K T = 500 Cp = 28.09 + 0.1965e-2*T + 0.4799e-5*T^2 - 1.965e-9*T^3

  Now try running the script

  >> CpAir T = 500 Cp = 30.0266 >> help CpAir Heat capacity of air in J/(mol K), where T is in K. The equation is valid only in the range 273 K < T < 1800 K

  Flow control

  Now let us check to make sure T is in the proper range
  
  Download Cpscript.m

  % Heat capacity of air in J/(mol K), where T is in K. The % equation is valid only in the range 273 K < T < 1800 K for T = 10:500:2500 % loop begins at T=10, increments by 500, ends after 2000 T % echos value of T if T < 273 disp('Temperature too low') elseif T > 1800 disp('Temperature too high') else Cp = 28.09 + 0.1965e-2*T + 0.4799e-5*T^2 - 1.965e-9*T^3 end end

  Now try running the script

  >> CpAir T = 10 Temperature too low T = 510 Cp = 30.0797 T = 1010 Cp = 32.9456 T = 1510 Cp = 35.2340 T = 2010 Temperature too high

  Functions

  To maximize the utility of the program we've written, we put it into the form of a function:
  
  Download Cpfun.m

  function Cp = CpAir(T) % Heat capacity of air in J/(mol K), where T is in K. The % equation is valid only in the range 273 K < T < 1800 K % % Called as Cp = CpAir(T) if T < 273 disp('Temperature too low') Cp = -1; % Return obviously incorrect value elseif T > 1800 disp('Temperature too high') Cp = -1; % Return obviously incorrect value else Cp = 28.09 + 0.1965e-2*T + 0.4799e-5*T^2 - 1.965e-9*T^3; end end

  Now try using the function

  >> CpAir(500) ans = 30.0266 >> Cp = CpAir(2000) Temperature too high Cp = -1 >> T = [300:10:1500]; >> for i = 1:length(T) Cp(i) = CpAir(T(i)); end >> plot(T,Cp)

  Numerical integration

  Download the following function
  
  Download lorfun.m

  function f = lorfun(t,s) % Lorenz attractor sigma = 10; rho = 28; beta = 8/3; x = s(1,1); y = s(2,1); z = s(3,1); f(1,1) = -beta*x + y*z; f(2,1) = sigma*(z-y); f(3,1) = -x*y + rho*y - z;

  and then try
  
  

  [T,Y] = ode23('lorfun',[0 40],[5 20 -10]); plot(T,Y) plot3(Y(:,1),Y(:,2),Y(:,3))

  Printing, saving, hardcopies

  >> diary on >> diary off >> print -djpeg myplot.jpg

  Introduction to object-oriented programming in Matlab

  Up to now we have focued on procedural programming techniques: translating numerical algorithms into source code in a very "top-down" approach.

  Now we shift our focus to the data being processed

  • Defining new data types and the functions (methods) that operate on them
  • Why? Because this approach results in more reliable and reusable software, especially for large projects.

  In Matlab, we have encountered such data types as

  • double (the default data type)
  • char

  We now examine the struct data type which allows storage of set of variables of possibly different type in one variable:

  A.val = 1.3
  A.units = 'm'

  Definition: A class defines the data fields of particular stuctures (objects) of that class and the methods that can be used on objects of that class

  Example: We consider developing the "dimensional" class, with two data fields:

  numerical value : A.val
  units : A.units

  and the following methods

  • constructor method (Dimensional.m)
  • display method (display.m)
  • addition + (plus.m)
  • multiplication .* (times.m)

  Because plus.m and times.m are already defined in Matlab as functions that normally operate on variables of type double, we will be overloading these methods by our new definitions.

  We define our new class in Matlab by creating a new directory named @Dimensional. Inside this directory (folder), we place the constructor function Dimensional.m

  function B = Dimensional(val,units) % Dimensional class contructor method A.val = val; A.units = units; B = class(A,'Dimensional');

  a display method display.m

  function display(A) % Dimensional class display method disp([num2str(A.val),' ',A.units])

  the overloaded addition function plus.m

  function C = plus(A,B) % Dimensional class plus (+) method if strcmp(A.units,B.units) val = A.val+B.val; units = A.units; C = Dimensional(val,units); return end error('Units mismatch')

  and the overloaded term-by-term product method times.m

  function C = times(A,B) % Dimensional class times (.*) method val = A.val.*B.val; if strcmp(A.units,B.units) units = [A.units,'^2']; else units = [A.units,' ',B.units]; end C = Dimensional(val,units);

  Consider then, defining

  x = 1.3 m
  y = -2.0 m
  z = 5.0 sec
  

  using the calls to the constructor method Dimensional.m

  >> x = Dimensional(1.3,'m') 1.3 m >> y = Dimensional(-2,'m') -2 m >> z = Dimensional(5,'sec') 5 sec

  and noting the format of the echoed output, defined by the display.m method. We then try out representative calculations with our overloaded methods:

  >> x + y -0.7 m >> x .* y -2.6 m^2 >> x .* z 6.5 m sec >> x + z ??? Error using ==> Dimensional/plus Units mismatch >> x==y ??? Error using ==> == Function '==' not defined for variables of class 'Dimensional'.

  Note that MATLAB returns an error as a result of the final command because the definition of equivalence (eq.m) has not yet been defined for objects of the Dimensional class.

  Inheritance

  The Dimensional class was constructed from scratch by defining a new data type and its associated methods. We can also build new classes from existing classes, where this child class inherits all the data fields and methods of the parent class; new data fields can be added to the child as well as methods. The new methods either overload some or all of the parent's methods, and entirely new methods can be defined. In either case, the methods defined for the child class can access data fields defined specifically for the child class or fields that were inherited from the parent.

  Consider, for example, changing the constructor method for the Dimensional class to the following:

  function B = Dimensional(val,units) % Dimensional class contructor method A.val = val; A.units = units; B = class(A,'Dimensional',Comparable);

  The Dimensional class now inherits the single method of the Comparable class, which is the equivalence operator (==). Therefore, we now can determine if two objects are the same:

  >> x == y ans = 0 >> x == x ans = 1