Matlab

Matrices

Basics

See the Introduction to Matlab lecture.

Special matrices/vectors

Name (matrix type)	Matlab syntax	Result
Ones	>> ones(3,2);	$ \left[ \begin{array}{cc} 1 & 1 \\ 1 & 1 \\ 1 & 1 \end{array} \right] $
Zeros	>> zeros(3,1);	$ \left[ \begin{array}{cc} 0 \\ 0 \\ 0 \end{array} \right] $
Eye (identity)	>> eye(3);	$ \left[ \begin{array}{ccc} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{array} \right] $
Rand (random numbers)	>> rand(3,2);	$ \left[ \begin{array}{cc} 0.21955 & 0.27560\\ 0.42385 & 0.62212\\ 0.53343 & 0.69182 \end{array} \right] $
Meshgrid	>> [x,y] = meshgrid(1:4,1:4);	$ x = \left[ \begin{array}{cccc} 1& 2& 3& 4\\ 1& 2& 3& 4\\ 1& 2& 3& 4\\ 1& 2& 3& 4 \end{array} \right] $ $ y = \left[ \begin{array}{cccc} 1& 1& 1& 1\\ 2& 2& 2& 2\\ 3& 3& 3& 3\\ 4& 4& 4& 4 \end{array} \right] $
Magic (magic square matrix) (The sum of each row and column is equal to the same value)	>> magic(4);	$ \left[ \begin{array}{cccc} 16& 2& 3& 13\\ 5& 11& 10& 8\\ 9& 7& 6& 12\\ 4& 14& 15& 1 \end{array} \right] $
Linspace	>> linspace(A,B,N)	$ \left[ A + \left( \frac{i}{N-1} \right) B \right] \qquad i=0, \dots, N-1 $
Logspace	>> logspace(A,B,N)	$ \left[ 10^{A} + 10^{ \left( \frac{i}{N-1} \right) B } \right] \qquad i=0, \dots, N-1 $

Functions

Function name	Matlab syntax/output
det	Returns the determinant of a matrix: >> A=magic(4) A = 16 2 3 13 5 11 10 8 9 7 6 12 4 14 15 1 >> det(A) ans = -1.4495e-12
find
flipud
fliplr
length
max
min
repmat	This function creates a new matrix consisting of several copies of an existing matrix. >> A = magic(3) A = 8 1 6 3 5 7 4 9 2 >> repmat(A,2,2) ans = 8 1 6 8 1 6 3 5 7 3 5 7 4 9 2 4 9 2 8 1 6 8 1 6 3 5 7 3 5 7 4 9 2 4 9 2
size
sort

Matrix operators

Addition, subtraction

Addition/subtraction can be done with vectors or matrices as with numbers:

>> A=ones(2,3)
A =

   1   1   1
   1   1   1

>> B=ones(2,3)
B =

   1   1   1
   1   1   1

>> C = A + B
C =

   2   2   2
   2   2   2

>> C = A - B
C =

   0   0   0
   0   0   0

Multiplication, division

Multiplication of matrices requires that the inner dimensions must match - i.e. $ (M \times N) \times (N \times P) $. If this criteria is met, then two matrices can be multiplied using normal multiplication syntax.

>> A
A =

   0.85645   0.86793   0.39228
   0.22329   0.82611   0.40042
   0.79097   0.45921   0.30861

>> B
B =

   0.976938   0.200895   0.239939
   0.300156   0.205414   0.963250
   0.396226   0.425022   0.041877

>> C = A*B
C =

   1.25264   0.51707   1.05796
   0.62476   0.38474   0.86609
   1.03284   0.38440   0.64504

Division of matrices is defined as $ A/B = A B^{-1} $. The same criteria applies, the dimensions of $ A $ must match the dimensions of $ B^{-1} $. If they do, then division can be done using normal division syntax.

>> A = rand(3,3)
A =

   0.85645   0.86793   0.39228
   0.22329   0.82611   0.40042
   0.79097   0.45921   0.30861

>> B = rand(3,3)
B =

   0.976938   0.200895   0.239939
   0.300156   0.205414   0.963250
   0.396226   0.425022   0.041877

>> 

>> C = A/B
C =

   0.015664   0.321640   1.879233
  -0.763591   0.516569   2.054946
   0.435077   0.177713   0.788906

>> C = A*inv(B)
C =

   0.015664   0.321640   1.879233
  -0.763591   0.516569   2.054946
   0.435077   0.177713   0.788906

Colon operator

The colon operator can be used to create a vector, similar to linspace:

>> 1:10
ans =

    1    2    3    4    5    6    7    8    9   10

The interval between elements can also be specified by using two colons:

>> (1:0.5:10)'
ans =

     1.0000
     1.5000
     2.0000
     2.5000
     3.0000
     3.5000
     4.0000
     4.5000
     5.0000
     5.5000
     6.0000
     6.5000
     7.0000
     7.5000
     8.0000
     8.5000
     9.0000
     9.5000
    10.0000

>> (1:0.8:10)'
ans =

     1.0000
     1.8000
     2.6000
     3.4000
     4.2000
     5.0000
     5.8000
     6.6000
     7.4000
     8.2000
     9.0000
     9.8000

The vectors with intervals of 1 can be used to access elements of a vector or a matrix. To access indices M through N, the syntax M:N can be used:

>> A = magic(4)
A =

   16    2    3   13
    5   11   10    8
    9    7    6   12
    4   14   15    1

>> A(1:2,1:2)
ans =

   16    2
    5   11

The colon operator by itself can also indicate an index ranging the entire length of the vector or matrix:

>> A(1,:)
ans =

   16    2    3   13

Component-wise operators

Component-wise multiplication and division can also be done. For two vectors $ a_{i}, b_{j} $ or two matrices $ A_{i,j}, B_{m,n} $ and some arbitrary operator $ \lozenge $, the component-wise vector operation is defined as

$ \begin{array}{rcl} c_{k} &=& a_{k} \, \lozenge \, b_{k} \end{array} $

and the component-wise matrix operation is defined as

$ \begin{array}{rcl} C_{p,q} &=& A_{p,q} \, \lozenge \, B_{p,q} \end{array} $

This component-wise operation can be done in Matlab by putting a dot in front of the operator: $ .\lozenge $

>> A
A =

   0.85645   0.86793   0.39228
   0.22329   0.82611   0.40042
   0.79097   0.45921   0.30861

>> B
B =

   0.976938   0.200895   0.239939
   0.300156   0.205414   0.963250
   0.396226   0.425022   0.041877

>> C = A.*B
C =

   0.836694   0.174363   0.094122
   0.067023   0.169693   0.385709
   0.313402   0.195175   0.012924

>> C = A./B
C =

   0.87666   4.32032   1.63489
   0.74392   4.02167   0.41570
   1.99626   1.08044   7.36944

However, if a component-wise operator operates on two vectors or matrices, the vectors or matrices must be the same size. Otherwise, the operator will not work.

This can also be done with exponential operators:

>> A=rand(4,1)*10
A =

   5.91734
   0.22397
   8.80927
   6.08892

>> A.^2
ans =

   35.014866
    0.050161
   77.603268
   37.074953

Functions

If a vector or matrix is fed to a built-in Matlab function such as sin() or exp(), the function operates component-wise on the vector or matrix. For example:

>> x = ( 0:pi/4:2*pi )'
x =

   0.00000
   0.78540
   1.57080
   2.35619
   3.14159
   3.92699
   4.71239
   5.49779
   6.28319

>> sin(x)
ans =

   0.00000
   0.70711
   1.00000
   0.70711
   0.00000
  -0.70711
  -1.00000
  -0.70711
  -0.00000

Combined with the colon operator or linspace function, this provides a very easy way to evaluate a function at many points.

Meshgrid can also be used to evaluate a function of two variables, in a form that is convenient to plot:

>> [x,y] = meshgrid(0:pi/4:2*pi, 0:pi/4:2*pi);
>> z = x .* sin( x - y );

This results in a set of 3 matrices that are particularly convenient to plot using surf or contourf (more on these plotting functions below).

>> surf(x,y,z)

Input/output

Reading Data Files

You can read in data files with the textscan function.

Batch File Loading

You can load a batch of files (say, all the files in a given directory) as follows.

Pick a directory

This can be done using either a GUI interface:

>>> directory_name = uigetdir('/path/to/starting/point','Pick a directory:');

once you pick a directory, it is of type char:

>>> directoryname = uigetdir('/path/to/starting/point','Pick a directory:');

>>> class(directoryname)

ans =

char

Alternatively, since the directory name simply needs to be stored as a char, you can hard-code your own directory:

>> directoryname='/uufs/chpc.utah.edu/common/home/u0552682';

>> class(directoryname)

ans =

char

You can also specify particular files, or file-matching patterns, as part of the path:

>> directoryname='/uufs/chpc.utah.edu/common/home/u0552682/files/*.txt';

Get the directory listing

>> ls = dir(directoryname)               

ls = 

146x1 struct array with fields:
    name
    date
    bytes
    isdir
    datenum

>> class(ls)

ans =

struct

The elements of this struct can be accessed as follows:

>> ls(1)

ans = 

       name: '.'
       date: '28-May-2011 00:04:50'
      bytes: 0
      isdir: 1
    datenum: 7.3465e+05

>> ls(5)

ans = 

       name: 'i002_j072_k072.dat'
       date: '14-May-2011 17:50:10'
      bytes: 1002884
      isdir: 0
    datenum: 7.3464e+05

Individual fields of each struct element can be accessed like this:

ls(1).name

ans =

.

>> ls(5).name

ans =

i002_j072_k072.dat

Get the directory listing of interesting files

To exclude uninteresting entries like "." and "..", you can also use file-matching patterns:

>> directoryname = '/uufs/chpc.utah.edu/common/home/u0552682/files/*.txt';

>> ls = dir(directoryname)

ls = 

26x1 struct array with fields:
    name
    date
    bytes
    isdir
    datenum

Looping over files in directory

You can now loop through the directory listing, which is stored in the structure ls, and load the file if it is not a directory:

for d=1:length(ls)                                                     
    if ~ls(d).isdir                                                    
        filename = fullfile('/absolute/path/to/files/',ls(d).name]);         

        % open/load the file here
    end                                                                
end 

Opening/loading files

This is something that will be specific to your own file format. You'll want to read through the Matlab documentation for the textscan function [1], or if your text files are simpler you will probably want to just use the simpler load function [2].

fid=fopen(filename);
AllData{d}=textscan(fid,'%f %f %f %f %f %f %f %f %f %f','CommentStyle','#');
fclose(fid);

This loads a file that consists of 10 numbers, separated with spaces, and with all comment lines commented with a hash symbol.

Saving Data to a File

If you have variables in your workspace that are processor-intensive to calculate, and that you want to be able to load many times in the future, you can save your workspace rather than re-calculating the variables every time.

The save() command will save workspace variables to a file.

Ascii vs. Mat format

The ASCII format will take up a lot more space, because it's saving everything out in human-readable ASCII format. This is useful if, say, you want other programs to read Matlab's saved workspace variables.

To save a variable 'really_big_variable' to an ASCII file,

save('really_big_variable.txt', 'really_big_variable', '-ASCII');

On the other hand, the MAT format is a binary format, meaning it is more compressed, but not as straightforward for other programs to read.

To save a variable in MAT format:

save('really_big_variable.mat', 'really_big_variable', '-MAT');

File I/O References

• Save(): http://www.mathworks.com/help/techdoc/ref/save.html
• Exist(): http://www.mathworks.com/help/techdoc/ref/exist.html
• Load(): http://www.mathworks.com/help/techdoc/ref/load.html
• Textscan(): http://www.mathworks.com/help/techdoc/ref/textscan.html
• Loading files in a directory: http://answers.yahoo.com/question/index?qid=20090118182802AAn1D6n

Matlab Object Programming

http://www.mathworks.com/help/techdoc/matlab_oop/ug_intropage.html

"The object-oriented programming capabilities of the MATLAB language enable you to develop complex technical computing applications faster than with other languages, such as C++, C#, and Java."

This is very true.

Matlab Classes

Using the whos command, you can see types of objects

alt, use class(variable), e.g.:

>>> a = 5+5;
>>> class(a)

ans =

double

See also

• Introduction to Matlab (lecture)

References

• Octave: http://www.gnu.org/software/octave/