CS 30 Review of Matlab for Midterm Test

Mart Molle, Spring 2016

Basic Features

• The command prompt, ">>", where you can enter commands one-at-a-time and see the answer. (Note: I will follow the convention that user-generated input is shown as bold underline blue text, Matlab-generated output is shown in italic, and blank lines are dropped whenever possible to reduce the length of this document.) e.g.,

• Multiple commands can be put on one line separated by a comma (",")  or semicolon (";"). A command ending with a semicolon does not produce any output. Commands can extend across multiple lines by placing the continuation symbol ("...") anywhere that white space is allowed (i.e., NOT in the middle of a number or variable name!!), for example, only the second command generates output:

• Rules for constructing valid variable names and arithmetic expressions (see p. 6 and 7). Note the distinction between "reserved words" (such as "for", "while",  "end", etc -- see list on page 8) and pre-defined "special variables" (such as "pi" [== 3.14159], "inf" [== 1/0, infinity], and "nan" [==0/0, not-a-number]) that are initialized to some well-known important value but can be changed at any time to something entirely different under user command. (Beware!)
  

• Normally, all numbers are represented as double precision floating point values (i.e., "scientific notation", with a fractional part and exponent). Integers can be taken care of "for free" by treating them as a special case where we essentially fix the exponent to turn the fractional part into a whole number. The type of value  associated with each variable can be changed at any time, and can be found using the "class" command
  

• Although all numbers are normally stored in double precision floating point format, you can override this default and specify a variety of other formats that occupy 8, 16, 32 or 64 bits of memory. However, since memory is now so plentiful, it is rarely worth the effort to try to squeeze the data into less space -- unless you have a huge volume of data (e.g., social security numbers for everyone in the USA), or you are attempting export or import data to another application that uses a different format.

• Because floating point numbers cannot store an exact representation for every real number, the results of a calculation may differ from what would be expected in pure mathematics:

Script M-Files

• A sequence of Matlab commands can be placed in a file (such as "newcmd.m") using the Matlab editor to create your own multi-step named command sequences. (Technically, this is called a "macro", rather than a "function", because executing the command is like pasting the contents of the file into the command window.) Once the script has been created and loaded into your workspace (e.g., by selecting "save and run" from the Editor's debug menu), it can be executed whenever you want by typing the filename (without the ".m" extension, such as "newcmd" in this example).
• You can use "echo off" and "echo on" to choose whether or not Matlab will print the commands within the M-file as if they were being typed by the user. However the display of the output is not affected by the setting of "echo" and can be stopped by ending each command by a semicolon as before.
• Several commands are available to support interaction between the user and the M-file during execution. For example

• The first argument to the "input" function is a string expression that will be displayed on the commmand line before waiting for user input. In the above examples, this argument was a fixed character string. However, you can construct a customized string by piecing together different parts within square brackets "[" and "]", like this:

•  Alternatively, if you just want to provide output without also waiting for the user to give you an input value, use can use the "disp" function to display its string argument, or you can use the "fprintf" function to generated formated output, like this:

• "fprintf" uses its first argument as a "template" for what the output line is supposed to look like, but it replaces each "format operator" (in this example, they are "%s" and "%d", which represent a string and integer numerical value, respectively) by values obtained from its other arguments.
  

Arrays and Array Operations

• Matlab is designed as a toolset for manipulating arrays (vectors, matrices, etc), so it is best to think about all variables as if they were a two-dimensional table of values (all with a single shared type). The command "size" tells you the current number of rows and columns occupied by any object:

• Surrounding a list of values separated by white space and/or commas by a pair of square brackets "[", "]" is used to construct a row vector. Each time a semicolon or newline appears within the list, a new row is started. All rows must have the same number of columns, and if the array elements are strings then each row must have the same total number of characters.

• Elements of the array are accessed by specifying their respective (row, column) locations within the table. Within each dimension (i.e., row or column) the numbering scheme always starts with 1 as the first element, and the the keyword "end" always gives you the last element. Thus, unless array "A" is empty, "A(1,1)" refers to the element in the first row, first column, and "A(end,end)" refers to the element in the last row, last column. More generally, the row or column subscript can itself be a list (array) of values, in which case the expression refers to a group of elements from the array.

• Another way to construct an array is simply assigning values to an element. If the element is already part of the array, its value is updated. Otherwise, the size of the array is expanded to the smallest (row, column) rectangle large enough to hold all of the assigned values WITHOUT COMMENT, and the newly-created entries are set to zero. On the other hand, attempting to access a non-existent element of the array when evaluating an expression is an error.
  

• The colon is used to construct arrays of sequential values. Two values separated by a colon constructs an increasing sequence that starts with the first value and then keeps increasing by steps of one as long as it is below the second value. Three values separated by two colons treat the middle value as the step size. Note that the colon expression does NOT need to be enclosed in square brackets because it is ALREADY a row vector.
  

• The colon operator can also be used to generate ranges of subscript (similar to cell addressing in Microsoft Excel spreadsheets) in order to access (parts of) an array. Furthermore, a single colon (with no values before or after it) has a special meaning when used as an array subscript, namely a shortcut for the expression "1:end" that represents the entire range of values for that dimension.
  

• An array reference with a single colon has a special meaning, no matter what the size or shape of the array:  form all elements from the array into a single column, with column 1 on top and column end on the bottom. More generally, for an array of any size or shape, you can access its elements through one-dimensional array references instead of the usual (row,column) form. In this case, we call the resulting value(s) an array index, rather than an array subscript, and interpret them as positions in the "single colon" version of the array. (The zyBooks text, section 8.2 calls this feature linear indexing.)
  

• Arithmetic and/or logical expressions are extended to arrays in two different ways. First, scalar operations (such as "+" or ">") apply the same formula independently to each element of the array. In this case, the two arguments must have exactly the same size and shape. However, if one of the arguments is a scalar (single) value it will be automatically expanded to the required size with duplicate copies of the scalar value.

• The alternative is vector (or matrix) operations, the simplest of which is matrix multiplication. In order to calculate C=A*B, the number of columns in A must match the number of rows in B, and the dimension of C will be the number of rows from A and number of columns from B. In this case, C(i,j) is the sum of all terms obtained by multiplying each element from A(i,:) by the corresponding element from B(:,j).

• The "find" function returns the locations within a matrix expression where there are non-zero (ie. "true") values. BEWARE that the results generated by "find" are in the "single colon" one-dimensional column index form, UNLESS the result is assigned to an array constructed from the names of two variables!!!

• For functions like "find", which generates a variable number of solutions in an array, it is important to know how to classify the result as a "success" or "failure". Matlab provides several ways to determine the number of results generated, including "size", "length", "numel" and "isempty". However, interpretting the answers can be tricky because Matlab's representation of an empty array is inconsistent between a zero-element array (i.e., "[ ]", which has zero rows and zero columns) and a sequential array that ends before it begins (i.e., "4:2", which has one row and zero columns). I think "isempty" and "numel" seem to cover most situations with the fewest surprises....
  

Character Strings

• In Matlab, a string is a sequence of characters between single quotes, and it can be manipulated just like a one-dimensional row vector. In other words, strings can be concatenated by enclosing them between a pair of square brackets, and pieces from the string can be selected and/or changed using array references.

• Since strings are implemented as one-dimensional character arrays, it is not possible to construct a row-vector of strings because the square brackets will simply concatenate them into a single string. (Of course, a cell array can easily handle strings as the contents of each cell -- but that adds an extra layer of complexity!)  On the other hand, enclosing a series of strings separated by semicolons between square brackets will create a column-vector of strings -- but it is awkward to use because the requirement that the dimensions of all arrays must be rectangular forces all of the strings (i.e., rows) to have the same length. Matlab provides the "char" and "strvcat" functions to take care of extending all strings to the maximum length.
• Note the distinction between the numeric code that is used to represent each character of an (extended) alphabet, versus the numeric value corresponding to a string of digits.

• A different set of functions is required to convert back and forth between a string of digits and the corresponding number, such as "num2str", "str2num", etc. 
  

Relational and Logical Operations

• Relational operators are used to make comparisons between two values (see the table on page 189). Note that the comparison for equality uses "==" because a single equal sign is already being used for the assignment statement, and that not equals uses "~=" (as opposed to "!=" in C). The result of a comparison is either "true" (indicated by a non-zero value, usually 1) or "false" (indicated by zero).
• The results of several comparisons can be combined using logical operators, AND, OR or NOT (represented by "~"). In Matlab, AND and OR come in two different flavors: "&&" and "||" use lazy evaluation, where the second operand is ignored if the result is completely determined by the first operand, whereas "&" and "|" evaluate both operands whether they need to or not.
  

Control Flow

• "if" statements provide a means for selecting which commands to execute based on the value ("true" or "false") of a condition. Every "if" has a matching "end", so any number of commands can be included within its body, to be executed if the condition is "true". "elsif" and "else" parts are optional.
  
• At most one group of commands will be executed from each "if" statement, namely those directly below the first "if" or "elsif" for which the condition is "true", if any. Otherwise, it will be the commands below the "else", if there is one.
• "while" and "for" statements provide a means for repeated execution of the commands in the loop body (down to the matching "end").
  
• "while" loops have a condition at the top. If the condition is true when we check it at the top of the loop, we execute the entire loop body before checking the condition again, and so on indefinitely until the condition becomes false.
• "for" loops specify a list of values for the index variable. At the top of the loop, the index variable is assigned to the next value from the list (if any), and then we execute the entire loop body before updating the value of the index variable again. Note that Matlab uses an array to represent the list of values for the index variable in a for loop, and if the array is two-dimensional then the index variable is assigned to the columns of the array, one at a time.
• The "break" command can be used to force an early exit from the nearest enclosing "while" or "for" loop.
• The "continue" command can be used to jump to the bottom of the nearest enclosing "while" or "for" loop. In other words, you skip the rest of the statements inside the loop body. However, you do NOT exit the loop completely (the way you do with "break") and so go back up to the top and retest the condition for a "while" loop or advance to the next value of the index variable.

Cell Arrays and Structures

• The primary feature of a cell array (as opposed to a "plain" array) is that every element can have its own class. You can create a cell array from a list of elements by enclosing it between a pair of curly braces "{", "}". Just like "plain" arrays, elements within the same row are separated by commas or white space, and every newline or semicolon indicates the start of a new row.
  

• The curly braces also play a special role when accessing the elements of a cell array. Enclosing subscripts in parentheses is used to specify cells (i.e., the containers), whereas enclosing the subscripts in curly braces specifies their contents (i.e., the data inside those cells).
  

• Since the contents of different cells is unrelated, in terms of both class and size, cell arrays are particularly useful for creating arrays of strings. This is because strings are just 1D vectors of characters, so it is impossible to make a row vector strings (all the characters just merge to form a single string), and you cannot make a column vector of strings (which is really a 2D array of characters) unless all the rows are the same length.

• Notice that Bag{2,1} i.e., the contents of the cell container in row 2, column 1 of the cell array, is itself an ordinary 2D array of doubles. Thus, I can select a specific element or group of elements from that ordinary array by adding a further level of array indexing using regular parentheses, as if Bag{2,1} was the name of an ordinary 2D array. The zyBooks text discusses this distintion in section 14.3, where it uses the terminology cell display indexing versus cell contents indexing.  Here is an example showing how to use curly braces and regular parenthesis, one after the other, to access part of the contents of a cell:

• Since Bag(1,1) is one cell from an array of cells, any value assigned to it must itself be a cell, whereas is contents Bag{1,1} can hold anything. Just like a "plain" array, assigning a value to a non-existent cell causes the boundaries of the array to expand. However, the newly created cells are initialized to empty lists ("[ ]") rather than the number zero.
  

• A structure array consists of multiple elements, called fields, that may have different data types and are identified by their respective field name, rather than a numeric index or subscript. New fields can be added to a structure at any time, merely by appending a dot followed by the new field name to the array. The overall structure, or any of its fields, can be turned into arrays by adding a subscript or index.

Functions

• Matlab "custom functions" (i.e., those you construct yourself, as opposed to those built in to Matlab) are very similar to script m-files:
1. They consist of named sequences of Matlab commands stored in a file.
2. You must choose a name for each of your command sequences, such as TryMe. Once you have constructed such a command sequence, Matlab to execute that command sequence whenever you type its name.
3. The file name is the same as the command sequence name, except that it is extended adding ".m" to the end, such as TryMe.m in this example.
   
• This requirement is not true for sub-functions, which are written another function in the same file. Sub-functions can only be called by other functions whose definition is part of the same file, since Matlab only knows how to find functions that are stored in files having the same name.
  
4. Executing a command sequence means temporarily stopping execution at the place where its name was called, going through the command sequence in the file, then resuming execution at the place where its name was called.
• However, there are several important differences between scripts and functions:
1. A script executes in the same workspace environment as the place where its name was called (typically, the "base" workspace for the Matlab command window), whereas a function executes in its own private workspace.
• A script shares all variables with the calling environment. If a script carries out the assignment x=0; then that variable assignment will still be visible when execution resumes afterwards.
• All variables you can touch inside a function are local to that function. You cannot access any variables from the calling environment, and any variables created during the function execution disppear when execution resumes afterwards.
2. Only functions can have arguments, which are used for passing values back and forth between the function and its calling environment.
   
• The arguments are defined on the first line of the function definition, like this:

• To the left of the equal sign is a vector of output arguments (in this case, a and b). These will be treated as variables within the function and their final values will be returned to the calling environment.
  
• To the right of the equal sign is a list of input arguments (in this case, c and d). These will be treated as variables within the funcation and their initial values are obtained from the function call. Note that it doesn't matter whether the function call uses variable names or expressions to supply the values for the input arguments -- either way, only the values are passed into the function. Thus if the first input argument in the function call was some variable x in the calling environment, your function cannot affect the value of that variable x from the calling environment by changing the value of its local variable c.
• Matlab does not consider it a mistake when a function call does not supply values for all of its arguments. You can use the read-only variables nargin and nargout to determine how many arguments you actually received.
  
• A function handle is a special class of variable that allows us to pass a method of calling one function as an input argument to another function, allowing the second function to make calls to the first function. For example, UseMe=@cos; creates a method of calling the cos function, which can be passed as an input argument to the Matlab function fminbnd (UseMe, -1, 3) so it can find the minimum value for the function cos(x) within the inteval -1<=x<=3.
  
• An anonymous function is one that can only be accessed through a function handle, and has no separate life of its own (as a named function stored in its own file). Note that the "content" of the function can be any expression you could write on the right-hand side of an assignment statement, like this:

• coo