Hunter Liu's Website

1. MATLAB Crash Course

Welcome to Math 151A! As you know, we’ll be implementing a lot of the algorithms we learn about as we go.

We’ll be using the programming language MATLAB, which has a lot of built-in operations (e.g. graphing data, matrix operations) that other languages don’t have. Moreover, a bunch of people way smarter than me have optimised these operations to the moon and back.

As UCLA students, you should have a MATLAB license, and you can install MATLAB here. If you are having trouble installing or running MATLAB on your computer, you can also use MATLAB Online. Worst comes to worst, you can visit the PIC Lab (located on the second floor of MS) and access MATLAB on the computers there.

I’ll be assuming some background in C++ (PIC 10A or CS 31) or Python, but please reach out if you’re missing this background!

Fair warning: there is a ton of content to cover today, since I was tasked with “teaching MATLAB” during the first discussion. Here’s an outline of these notes if you need to jump around:

• Basics: Variables, Matrices, and Output
• Arithmetic and Boolean Operations
• Control Flow
• Scripts
• Functions
• Plotting
• Miscellaneous Functions and MATLAB Documentation
• Practise Problems

Basics: Variables, Matrices, and Output

Unlike C++ but like Python, MATLAB variables are not typed. To declare a variable, simply type VARIABLE = VALUE. Each variable name can hold one value at a time, and you can overwrite the contents of said variable whenever you want. You do not need to end every line with a semicolon, though adding a semicolon will have a different effect.

The value of a variable can be:

• A number, such as 3 or -7.14 or 9e14 (\(9\times 10 ^{14}\)).
• A string, such as "dog water" or 'bean juice'. You can use double quotes or single quotes, as long as they match up. You can store double quotes in a single-quoted string and vice-versa.
• A matrix, such as [1 2 ; 3, 4]. Semicolons separate rows while spaces and/or commas separate columns. This would be the matrix \(\begin{pmatrix} 1 & 2 \\ 3 & 4 \end{pmatrix}\).

We can see how variables work by using the command window:

>> A = 3e2

A = 

    300 

>> A = [1 2 ; 3, 4]

A = 

    1   2
    3   4

You’ll notice that MATLAB automatically prints out the value of A after every line. You can end a line with a semicolon to prevent this behaviour.

>> A = 3e2; 
>> A = [1 2; 3, 4] 

A = 

    1   2
    3   4

A bit more about matrices — you can access and even modify individual entries of a matrix. The syntax for the \(i\)-th row and \(j\)-th column of A is A(i, j).

For instance, the following code creates the matrix \(A\), then sets the entry in the second row and first column to a \(10\).

>> A = [1 2; 3 4]; 
>> A(2, 1) = 10; 
>> A 

A = 

    1   2   
    10  4

Arithmetic and Boolean Operations

In this class, we’ll be performing a lot of mathematical operations; many of these overlap with other languages you may be familiar with. Let’s begin with the common arithmetic operations:

• Addition: a + b
• Subtraction: a - b
• Multiplication: a * b
• Division: a / b or b \ a; both of these represent \(a\div b\).
• Exponentiation: a ^ b
• Modulo: mod(a, b)

Note that the modulo operator is no longer a % b. In addition to these, MATLAB has the following mathematical operations built in:

• Rounding: round, floor, ceil
• exp and log (both in base \(e\)).
• Trigonometric functions: sin, cos, tan, cot, sec, csc, all in radians.
• Inverse trigonometric functions: asin, acos, atan, acot, asec, acsc, with outputs in radians.

There is additional subtlety when performing matrix operations. All of these operations work element-wise on matrices except for multiplication and division. The * operator performs matrix multiplication, while the / and \ correspond to one-sided inverse operations.

Note that matrix multiplication is not commutative, so the order in which you divide matrices does matter quite a bit. We likely will not be using these operations in this class, but it’s important to make this distinction now. If \(A\) and \(B\) are two matrices, A / B corresponds to \(AB ^{-1}\) while B \ A corresponds to \(B ^{-1}A\). MATLAB will let you do this even if \(B\) is not invertible, though you will get garbage out the other end.

You have to make sure the dimensions match up! To perform element-wise multiplication and division, use .*, ./, or .\ (a dot preceeding the operation).

>> A = [1 2; 3 4]; 
>> B = [1 0; 0 2]; 
>> A * B 
ans =
1   4
3   8

>> B * A
ans =
1   2
6   8

>> A .* B
ans =
1   0
0   8

In addition to all of this, you can compute the transpose of \(A\) by adding an apostrophe: A'.

Finally, there are the boolean operations:

• Equality: a == b or isequal(a, b).
• Inequality: a ~= b
• Comparisons: a < b, a <= b, a >= b, a > b

Note that inequality is no longer !=, as in most other languages. Performing these operations on two matrices (of equal dimension) will produce a matrix of boolean (AKA logical) values unless you use the isequal function.

>> A = [1, 1; 2, 2]; 
>> B = [2, 1; 2, 1]; 
>> A == B 
ans =
2×2 logical array
0   1
1   0

>> isequal(A, B)
ans =
logical
0

The ones represent “true” and the zeroes represent “false”.

You can combine or modify multiple boolean expressions using the following operations: if c and d store boolean values,

• And: c & d or c && d. This is true if c and d are both true, false otherwise.
• Or: c | d or c || d. This is true if either c or d are true, false otherwise.
• Not: ~c. This flips a true to a false and vice-versa.

Control Flow

There are three constructs for this section: if statements, for loops, and while loops. Hopefully these are all familiar.

The syntax of an if statement is as follows:

1if CONDITION
2    ( code goes here )
3end 

The condition for the if needs to be a logical/boolean value, such as the result of a comparison. The if statement only ends when there is an end keyword; MATLAB does not use curly brackets (like C++) or indentation (like Python) to determine the scope of the if block. In addition, the condition for the if statement does not need to be followed by a colon.

The syntax of a for loop is quite different from C++ and more closely resembles Python. For loops repeat a block of code as a counter ranges over a sequence of values. To create a for loop, you need to know the starting value of the counter, the ending value of the counter, and the increment of the counter. The syntax is as follows:

1for COUNTER = START:INCREMENT:END 
2    ( code goes here ) 
3end 

The increment is optional and has a default value of 1; you could also create a for loop as follows:

1for COUNTER = START:END
2    ( code goes here ) 
3end 

Most generally, you’ll want to repeat some code (N) times; you can use

1for i = 1:N
2    ( code to be repeated )
3end 

Finally, there’s the while loop, which has syntax that nearly matches the if statement:

1while CONDITION 
2    ( code goes here )
3end 

Scripts

So far, we’ve been doing everything in the command window just to get a feel of the basic pieces of the language. This is not a practical way to use MATLAB, as you can’t easily go back and edit or correct your code, and it’s especially difficult to write out and organise complex code.

To create a new script, press the “Home” button followed by the “New Script” button on the upper-left corner of the MATLAB window.

To run a script, simply type the name of the script (without the .m file extension) in the command window. This will cause MATLAB to run every line in the script one after another, as if you had typed them directly into the command window.

This is a good time to introduce comments. Whenever MATLAB encounters a %, it ignores the % and everything on that line after it. This behaves just like // in C++ and # in Python.

Let’s write some quick pseudocode for this example.

• For each i between 1 and 100, perform the following:
  • if i is a multiple of 3 and not a multiple of 5, print i

This is the most underwhelming pseudocode I’ve ever written. Converted into code, we get:

1% loops through the numbers between 1 and 100
2for i = 1:100 
3    if (mod(i, 3) == 0) & (mod(i, 5) ~= 0) 
4        i % prints i and does nothing else 
5    end % ends if statement
6end % ends for loop

If this is saved as example.m, you would just type example into the command window to run it.

Functions

Perhaps the biggest syntactic difference between MATLAB and other languages is how functions are written. The general syntax is as follows:

1function [output1, ..., outputN] = function_name(input1, ..., inputM) 
2    ( code goes here )
3end 

There are no return types, and the number of inputs/outputs is predetermined. Functions cannot be defined in the command window; they must be placed inside a script.

In order to use a function in multiple different scripts, or to use a function directly from the command window, you need to place the function at the top of a script whose name matches said function. For instance, if you want to write and reuse a function named foo, you need to create a script named foo.m. The line function [...] = foo(...) needs to be at the top of foo.m!

Let’s do an example together.

In pseudocode, one way to perform this conversion is:

• Input: \((x, y)\in \mathbb{R}^2\)
• Set \(r = \sqrt{x^2+y^2}\).
• If \(x\neq 0\), set \(\theta = \arctan\left( \frac{y}{x} \right)\).
• Else if \(x=0\) and \(y>0\), set \(\theta = \frac{\pi}{2}\).
• Else if \(x=0\) and \(y<0\), set \(\theta = -\frac{\pi}{2}\).
• Finally, if \(x < 0\), add \(\pi \) to \(\theta \). (We have to do this because \(\arctan\) will always spit something out in the first or fourth quadrant.)
• Return \(\left( r, \theta \right)\).

Let’s call this function to_polar. So, we would need to make a script called to_polar.m; these would be its contents:

 1function [r, theta] = to_polar(x, y) 
 2    r = (x^2 + y^2)^0.5; 
 3    if x ~= 0
 4        theta = atan(y / x); 
 5
 6    % in the next two blocks, x will automatically be zero. 
 7    else if y > 0 
 8        theta = pi / 2; 
 9    else
10        theta = -pi / 2; 
11    end % of if/else chain 
12
13    % correcting arctan 
14    if x < 0 
15        theta = theta + pi; 
16    end % of if statement 
17end % of function to_polar

To use this, you may type [r, theta] = to_polar(3, 4), for insance. This would set r = 5 and theta = 0.9273. The name of the variables when you call the function doesn’t matter: you could just as well type [bob, joe] = to_polar(3, 4). (Please choose good variable names. I will hunt you down if you use bob and joe on your homework.)

Plotting

MATLAB’s plotting features are comprehensive, and the following is nowhere near a complete account of its capabilities. I think these basic functionalities that follow are enough for this class.

Let’s start with scatter plots. Suppose you want to graph three points: \(\left( 3,4 \right)\), \(\left( 1,7 \right)\), and \(\left( 5, 8 \right)\). You need two arrays (i.e. “row vectors”) — one containing the \(x\)-coordinates, one with the \(y\)-coordinates, each in the same order. Then, just feed these two arrays into the scatter function as follows:

1x = [3 1 7]; 
2y = [4 7 8]; 
3scatter(x, y); 

You’re going to end up with quite an awful graph, but it’ll just pop up automatically! MATLAB automatically scales the plot to be as small as possible. To avoid this, you can use the xlim and ylim functions, which allow you to set the minimum and maximum values of the (x)- and (y)-coordinate axes.

1x = [3 1 7]; 
2y = [4 7 8]; 
3scatter(x, y); 
4xlim([0 10]); 
5ylim([0 10]); 

Make sure to pass in the limits with brackets! MATLAB will freak out if you try to do xlim(0, 10).

Finally, we should add labels to everything. xlabel and ylabel add a label to the \(x\)- and \(y\)-axes; title adds a title to the plot. Each of these takes one string argument. For instance:

1x = [3 1 7]; 
2y = [4 7 8]; 
3scatter(x, y); 
4xlim([0 10]); 
5ylim([0 10]); 
6xlabel("x coordinate"); 
7ylabel("y coordinate"); 
8title("Three points"); 

Finally, the command plot functions exactly the same way that scatter functions except it connects the points with lines instead of plotting individual markers. When using plot, it connects the points in order, and this can produce horrendous-looking garbage if you’re not careful about this.

Most commonly, you’ll want to plot the graph of some function (say, the solution to an ODE). You’ll need quite a few points to make the line plot not have choking hazards (i.e. for the graph to be smooth).

Suppose for instance you wanted to plot the function \(f(x) = \sin \left( x^2+3 \right)\) on the domain \(\left[ 0,5 \right]\). You would want to place a point at \(x=0\), \(x=0.1\), \(x=0.2\), etc. To do this efficiently, you can use x = 0:0.1:5, very similarly to the input in the for loop! This will produce a range of values between 0 and 5 in increments of 0.1.

To efficiently compute \(\sin\left( x^2+3 \right)\) on each value in x, we can just use sin(x .^ 2 + 3). The .^ is so that MATLAB knows to perform the squaring element-by-element rather than attempting to square a vector.

1x = 0:0.1:5; 
2y = sin(x .^ 2 + 3); 
3plot(x, y); 

You’ll notice that the plot is actually kind of bad since we’re not using enough points, but this gets the idea across. You can always increase the resolution by decreasing the increment/spacing of the points, e.g. x = 0:0.001:5.

Miscellaneous Functions and MATLAB Documentation

There are a handful of other functions that may be or may not helpful at some point in your existece.

The size function takes any matrix or array as an input and outputs the dimensions as a \(1\times 2\) row vector. For instance,

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

ans = 

    2   3

This gives you the rows and the columns, in that order. The size function does also work on deeper levels of nesting, e.g. on arrays of arrays of arrays, but that’s a bit more firepower that we’ll need. In a similar vein, the length function takes a 1-dimensional row vector or column vector and spits out the length (as you might expect).

Sometimes, you’ll want to initialise a vector or array and then fill them in later. One way to do this is with the zeros function, which takes in two integer arguments: zeros(r, c) constructs an \(r\times c\) matrix with every entry set to zero. Be warned that zeros(n) does not create an array of \(n\) zeroes, but rather an \(n\times n\) array of zeroes.

You can find more detailed information about any of the functions or operations discussed above on MATLAB’s documentation. There are thorough explanations and examples of all the different ways that you can use each of these functions.

Practise Problems