Guide for CS 1371

To Complete Homework Assignments:

1. Create a folder in your CS 1371 folder for the homework assignment. Make it easy to find. 2. Go to T-SquareàAssignments and click on the homework assignment. 3. Save each of the files under "Additional resources for this assignment" by right-clicking and selecting "save target as...". 4. Open MATLAB and change the directory to the specific homework folder. 5. Open the ABCs.m file and follow the directions. When you are finished, you can check your answers by running the ABCs pretest file. Right click the pretest in the directory and select "Run File." The pretest will display which answers are correct or incorrect on the command window. 6. Open the hw.m file and write your personal information at the top. The descriptions for the drill problems will include all inputs, outputs, and character classes. Always remember to check the character class of your outputs. Don't forget to comment your code. 7. Create a new file in the script editor for each drill problem. When you finish, test them thoroughly. If there are test cases on the hw.m file, you can uncomment them and run the hw file as long as your scripts are saved in the same directory. Alternatively, you can copy the test cases and run them from the command window. 8. After you complete the drill problems, update the information regarding collaboration on the hw.m file. Navigate back to the same assignment page on T-square and submit all files listed in the "Files to submit" list. 9. You can submit as many times as you want before the deadline and will frequently have opportunities to resubmit after you receive your grade. Resubmissions are graded as the average of the two submissions except on test weeks. Homework assignments are graded automatically by a computer. It will test each of your scripts or functions multiple times with various inputs determined by the TAs. They will use any means possible to make your code run an error and cause you to get a zero on the problem. For this reason, you should never rely solely on the test cases provided with the homework file. Make sure your functions can deal with inputs such as negative numbers, fractions, and empty vectors or strings. If you can find one output but not another, set the difficult output equal to something pointless like 6 so you can get partial credit. Remember: any code that runs an error results in a zero.

Section Eight: Cell Arrays

Cell arrays are another data type MATLAB utilizes to store information. Despite being intimidating for most people, cell arrays are easy to work with as long as you UNDERSTAND what they are. Seriously, you don't want to end up guessing when cell arrays appear on exams. Cell arrays are a unique data type in that they are capable of storing data of multiple other types. Each element in a cell array is a cell, and a cell can contain anything (doubles, logicals, strings, structures, or even other cells). My shorthand for a cell array is ca. Creating Cell Arrays: Cell arrays are collections enclosed in curly brackets. The only difference is that elements can now be of any data type. This is the easy part. ca = { [1 2 3], 'Judah', [true true false] }; Indexing Cell Arrays: The complicated thing concerning cell arrays is that they can be indexed in true different ways, using parentheses () or curly brackets {}. Indexing with parentheses returns the actual element (in a cell array, a cell), whereas indexing with curly brackets returns the CONTENTS of the element. In other words, curly brackets open a cell to display what it contains; only cells can be indexed with curly brackets. To return specific components of the contents of a cell, use curly brackets to open the cell followed by parentheses to index its contents. When cells are nested inside each other, you must use multiple sets of curly brackets to reach whatever is ultimately inside. The rule, which is well worth memorizing, is that you can only index with parentheses once, and the parentheses must come last in a set of indices; this makes sense if you pause to think about it. ca = {[true false], 'Reuben', {[1 2 3], 'Gad'}}; class(ca) ans = 'cell' class(ca(1)) ans = 'cell' class(ca{1}) ans = 'logical' ca(3) ans = {1x2 cell} ca{2} ans = 'Reuben' ca{2}(2) ans = 'e' ca{3}{1}(3) ans = 3 That's pretty much it for cell arrays. Remember that you still use square brackets, not curly brackets, when concatenating and deleting cell arrays. Most of my examples will involve intricate combinations of cell arrays and loops. When using cell arrays and especially iteration and conditionals, it is generally necessary to keep track of data types. The functions isdouble(), islogical(), ischar(), and iscell() return a logical true or false of whether the input is of the specified data type. The function isempty() returns true if the input is an empty string, vector, cell array, or structure array. Write a function Manasseh that takes in a cell array containing vectors of equal length and meshes them together into one long output vector. The first element in the output vector should be the first element of the first vector, followed by the first element of the second vector, and so on. Manasseh({[1 2 3] [4 5 6] [7 8 9]}) ans = [1 4 7 2 5 8 3 6 9] function out = Manasseh (ca) %Perhaps the most intuitive way to solve this problem would be to create a simple test case and focus %on the identity of the output in relation to the inputted cell array. For the cell array {[1 2] [3 4] [5 6]}, %the output is [ca{1}(1), ca{2}(1), ca{3}(1), ca{1}(2), ca{2}(2), ca{3}(2)]. It now becomes apparent that the %first index starts at one and approaches the number of vectors, and the second index starts at one and %approaches the length of the vectors. out = []; %The solution is deceptively simple but requires two simultaneous for loops. for i = 1:length(ca{1}) %The outer loop runs once for every element in the vectors (the vectors are all of equal length). for j = 1:length(ca) %The inner loop runs once for each vector in the cell array. out(end+1) = ca{j}(i); end end end Write a function Mephibosheth that takes in a string and divides it into individual words. The function should output a cell array containing one word per cell. Mephibosheth('Jacob I have loved') ans = {'Jacob' 'I' 'have' 'loved'} function out = Mephibosheth (str) out = {}; while ~isempty(str) %Iterate until there is no string remaining. [word, str] = strtok(str, ' ') %Reassigning the value of str moves us toward the condition that terminates the loop. out{end+1} = word; end %You'll be using this code to break down text from notepad files in a few weeks. end

Slicing Strings:

If you can slice vectors, you can slice strings. If you slice beyond the bounds of the original string, MATLAB will fill the intermediate spaces with ascii zeros, not 32s.

Strtok():

The strtok() function is used to split (tokenize) an input string into two parts based on the location of a specific character called the delimiter. Basically, you choose what character to search for (the delimiter) and MATLAB will divide the input string into two output strings according to the following rules: 1. MATLAB locates the first non-delimiter character and deletes all delimiters preceding it. 2. MATLAB locates the next delimiter after the character in (1). The first output is every character from the remaining string up to the character before the delimiter. The first output can NEVER contain the delimiter. 3. The second output is everything else, including the delimiter found in (2). 4. If the input is an empty string, both outputs will be empty strings. 5. If the string does not contain any delimiters, the first output is the entire string, and the second output is an empty string. 6. If the string contains only the delimiter, both outputs will be empty strings. Strtok() is one of the most important functions to know for MATLAB. It is used heavily in both string manipulation and file input/output

Indexing Strings:

You can index the elements in a string the same way you would with a vector. Just keep in mind that MATLAB now interprets EVERYTHING in the string as a separate element, including spaces and commas. Indexing strings returns the actual characters, not doubles.

Basic Arithmetic with Strings:

You can use basic arithmetic to change characters in strings to other characters. From our previous example, we know that adding 32 to a string of uppercase letters will convert them to lowercase. Just remember the golden rule of strings: whenever you add or subtract elements in strings, MATLAB always changes them back to doubles. You will therefore have to use char() to keep your original string format.

Basic Arithmetic:

All arithmetic calculations involving arrays are performed element-by-element. Remember to use the dot with multiplication and division

If Statements:

All if statements are coded in the following basic format: if <logical expression> <code block> end MATLAB will automatically turn the words "if" and "end" blue to designate them as markers pertaining to the code block in between them. MATLAB first evaluates the logical expression to the right of "if." If the statement is true, the code block between "if" and "end" is run as if the conditional statement did not exist. Otherwise, MATLAB jumps from "if" to "end" and ignores the code in between. More complicated conditionals can be created by adding the keywords "elseif" and "else." Elseif statements function like extra if expressions (logical1 was false, but maybe logical2 is true). You can have as many elseif statements as you want but each must contain its own corresponding code block. If you find that multiple statements contain the same code block, you should consider combining them into one logical statement using or (|). An else statement, if you use one, must be the final statement in your overall conditional. It functions like an elseif statement that is automatically evaluated as true. However, an else statement will by definition only be run if all preceding conditional statements are evaluated as false. The order of conditional statements is extremely important because MATLAB will run only the code block corresponding to the FIRST true logical expression. Thus, it will not evaluate any expressions following the first true one and will skip to "end" instead. Finally, EVERY conditional statement (if or switch) must have a corresponding "end." Failing to include enough "end"s will cause an error. MATLAB automatically aligns any "end" you type with the nearest designated conditional statement. If <logical expression1> <code block1> elseif <logical expression2> <code block2> elseif <logical expression3> <code block3> else <code block4> end

MATLAB's Secret Trick:

Although arrays are displayed in the command window as two-dimensional matrices of values, MATLAB actually stores the information as a very long column vector. It numbers the elements by reading down the columns one at a time, meaning that arrays can actually be indexed as if they were vectors. This can be useful to remember because it allows you to reshape arrays into vectors very easily.

Basic Arithmetic with Vectors:

Any basic arithmetic involving a vector and a constant changes the value of all elements in the vector. Remember to use the dot (.) with multiplication and division. vec = [1 3 5 7 9]; vec = vec + 2 vec = [3 5 7 9 11] vec = vec.*2 vec = [2 6 10 14 18]

The Assignment Operator:

Any line of code that uses a single equals sign (the assignment operator) is called an assignment statement. Assignment is used primarily to set values to variables and works the same way with any data type. All variable names are case-sensitive, so "a" and "A" can be used as separate variables. Be very careful when naming and accessing variables. Variable names are generally short enough to take up little space but long enough to be easily distinguished. The last thing you want to do is have to fix your code when you can't even figure out what it does. There are three important restrictions on naming variables: 1. A variable's name must begin with an uppercase or lowercase letter. The rest of the name may contain any combination of letters and numbers. 2. A variable's name cannot contain spaces. Obviously, MATLAB would then be unable to distinguish between the variable and the surrounding code. 3. A variable's name cannot contain any special characters except underscores. 4. A variable should never be given the same name as a built-in MATLAB function (min, max, sort,etc.) By these rules, the following would be legal variable names: A , a , a1 , a1a , a_a The following are therefore illegal variable names: 1 , 1a , a: , : , a 1, a? Assignment statements take the form A = B, where "A" is a variable or collection and "B" is an expression that can be immediately evaluated. MATLAB first evaluates "B" then sets "A" equal to it. Assignment statements do NOT establish relationships between variables; they can only be used to set a variable equal to a known value. Once again, changing the values of other variables used in an assignment statement has no effect on the previously outputted variable. If no "A" is inputted, the value of "B" will automatically be stored in MATLAB's temporary variable "ans." "ans" can be accessed at any time and is always placed in the workspace, but each new non-specific assignment statement overwrites whatever is stored in it. It is generally a bad idea to rely on "ans" to store any values you may be using later. By default, the result of an assignment statement is immediately displayed on the command window. However, this can become very irritating when you run long scripts or change large collections of values; the command window will quickly become clogged with useless information that slows the execution of your code. To prevent this, you can "suppress" the output of individual lines of code by ending them with a semicolon. The result of a suppressed output is still stored in the workspace but will not be displayed in the command window. With practice, you will learn to subconsciously suppress all outputs as you write. MATLAB will automatically notify you of unsuppressed outputs by discoloring the equal's sign Whenever MATLAB encounters spaces, it automatically ignores them. You can therefore add spaces in lines of code to make them more legible.

Creating Arrays:

Arrays are created using square brackets in much the same way as vectors. Simply enter the individual rows of the collection separated by semicolons. Yes, the semicolon also has many diverse uses. Arrays must always be rectangular; if at any point MATLAB attempts to create an array that is not rectangular, it will produce an error. arr = [1 2 3; 4 5 6; 7 8 9] ans = 123456789 arr2 = [1 2; 3 4; 5 6] ans = 123456 arr3 = [1 2 3; 4 5; 6 7 8] Error

Concatenating Arrays:

Arrays can be concatenated horizontally or vertically just like vectors. Once again, any command that would produce a non-rectangular array results in an error. [arr1, arr2] Concatenates horizontally [arr1; arr2] Concatenates vertically

Scripts:

As previously stated, using the command window to solve complex problems is inadvisable because it does not allow you to edit commands you have already run. Consequently, most coding is completed using scripts and the MATLAB function editor. A script is a blank space for inputting blocks of code or functions. When you finish writing a script, you can run the entire thing at once; if an error occurs, you can edit and rerun your code to your heart's content. To open a new script, click the icon in the upper-left corner that looks like a blank sheet of paper or press ctrl+n. When you finish typing out your code, you can run the script by using the green triangle icon or by pressing F5. To save, go to fileàsave as... or press ctrl+s. Scripts are automatically saved as .m files, the default file type for MATLAB. Always leave the file type as .m if want to receive credit. If MATLAB dislikes something you've written on a script, it will inform you by enclosing a variable inside a discolored box or by underlining part of your code in red. This is a very quick way to spot typos, but don't rely on it for everything. If you plan to test your script frequently, you can dock the script editor inside the command window. This will allow you to view the values of different variables from the workspace without having to minimize the script. To dock the editor, click the small arrow on the left just under the minimize button. The editor can be undocked in the same way by clicking the up-arrow above the minimize button. If you wish to run a script one line at a time rather than all at once, you can enter debug mode by clicking the gray space to the right of the line numbers on the left side of the screen. A red circle will appear on the debugged line. Any number of lines can be debugged. When run, the script will immediately proceed all the way to the first debugged line, then stop. You can then continue running each individual line by pressing the icon with the curvy blue arrow on top of a sheet of paper labeled "step." The "step in" icon allows you debug any internal functions that your script runs. "Continue" allows the code to run normally until it reaches the next debugged line. While in debug mode, you can display the values of any variables by hovering the mouse over them or by simply viewing their progress in the workspace. If you cannot locate the source of an error, debugging your script is an excellent way to track the problem. You can add your own personal comments to any of your code to make it easier for you or other people to understand. Simply precede any comments with a "%" percentage sign. MATLAB completely ignores any green text following a percentage sign when it executes code. To see an example, just look at a hw.m file. To comment a line of code, click on it and press ctrl+r. To uncomment something, press ctrl+t. It is not necessary to actually highlight the code you sigh to comment or uncomment. You can earn extra credit points on your homework assignments by commenting your code.

Nested Conditionals:

Believe it or not, you can actually place conditionals INSIDE other conditionals J. Sometimes, nesting conditionals is the only way to solve a particular problem. More frequently, however, you can use it to make your code more legible, pretty, and/or cool. Consider the following example: Write a function that takes in a vector and checks to see if all its elements are perfect squares between 6 and 23 that are not divisible by four. The function should output a logical true or false. As you can see, this code is much easier to understand than its one-line equivalent. Notice that a common strategy is to arbitrarily initialize the output variable as one possibility and change it depending on the result of the if statements; doing so ensure that your output variable will always be defined, thereby reducing the chance of your code producing an error.

Slicing Arrays:

By slicing arrays in creative ways, you can do all sorts of interesting things such as swapping rows or columns, mirroring, deleting elements, and flipping things upside down. Make sure you know and understand the first two, as they are extremely useful.

Section Six: Conditionals

Conditional statements allow you to determine whether or not to run a certain block of code based on some non-predetermined information. Basically, it's what you wish you could have been using for all the previous homework assignments. Conditionals come in two forms—if and switch statements, but knowing switch statements is more useful than absolutely necessary.

Splitting Arrays into Halves and Quarters:

Don't bother memorizing these. You can easily reproduce them with some practice. arr(1:round(end/2),:) Top half arr(round(end/2):end,:) Bottom half arr(:,1:round(end/2)) Left half arr(:,round(end/2):end) Right half arr(round(end/2):end, round(end/2):end) Bottom-right quarter

Writing Functions:

Except for a few lines of code, functions are absolutely identical to scripts. The main difference and, coincidentally, the easiest way to spot a function is the first line, the function header. The header contains all of the basic information concerning the function in the following form: function [output1, output2, output3] = name_of_function (input1, input2) or function output1 = name_of_function (input1) When you type the word "function", MATLAB should recognize it and color it blue. Please remember that spaces do not matter, but commas do. In situations with only one input/output, brackets may be excluded but parentheses are always necessary. A function can have any number of inputs or outputs, even zero. You can use the same variable as both an input and an output as long as you don't need to keep track of its original value. Although you will probably never encounter a function with no inputs, it is quite common for one to have no outputs if its purpose is simply to produce a plot or print something out to the command window. If the function has no outputs, eliminate the equals sign and outputs. Thus: function name_of_function (input1, input2, input3) Most functions are ended with the word "end" to let MATLAB know that the function is complete. Doing so is only completely necessary if you plan on using helper functions, which I will now explain. Although functions are normally called directly from the command window, they can actually call other functions as well, as long as all the files needed are saved in the current directory or added to the path. If you wish to perform a small task multiple times in a single function, you can write a small helper function to assist you. Just place the helper function after the "end" of the main function. Doing so can save space as well as make your code more readable. Here is an example of a helper function. function [out1, out2] = helperExample (a,b,c) out1 = confangleNumber(a); out1 = out1 - confangleNumber( a + (b - a).^3); out2 = confangleNumber(b + 6.*a); end function num = confangleNumber(num) num = abs(ceil(num + (num ./ 2).^2 - round( (num +1)/(num - 1).^2))) end As previously stated, it is not necessary to have any earthly idea about what a function actually does. When you attempt to save your function, MATLAB will automatically suggest the same name as the one given in the function header. Never name a function anything else. Because function are so versatile and easy to grade, this course relies primarily on function-writing for homework assignments and coding problems on tests. If you can't write a function properly, you're probably going to fail the class.

Section Nine: High-Level File Input/Output

File input/output, hereafter referred to as file IO, is a process by which MATLAB can read documents from other from other computer programs, manipulate them, and save them as new documents in your current directory. High-level file IO specifically involves dealing with highly organized data in notepad and Microsoft Excel. We will be working with three types of files: csv files, dlm files, and excel spreadsheets. The primary difficulty with file IO involves conversions between different data types. If you find yourself using loops to accomplish simple conversions or comparisons, you're probably doing something wrong. There are a few easy tricks that will make these problems much, much easier. Reading and Writing CSV Files: CSV stand for comma-separated values. Basically, a CSV file is a Notepad .txt document containing only an array of numbers separated by commas. Any spaces and empty lines in the file are completely ignored. If the document contains anything other than doubles (negative numbers and fractions are okay) and commas, it is not a CSV file. There are two functions you need to know. arr = csvread(filename) The function csvread() takes in the filename (always a string) of a .txt CSV file in your current directory, removes the commas, and outputs the resulting array of doubles. If the array is not rectangular, it fills any unused space with zeros. For example, csvread will turn the following file into the resultant array: csvwrite(filename, array) The other significant function is csvwrite(), which does exactly the opposite. It takes in an array of doubles and saves the corresponding CSV document as a file in your current directory. Please note that csvwrite(), and any writing function for that matter, does not have any output; you should not suppress it with a semicolon or set it equal to anything. Reading and Writing DLM Files: A dlm file is exactly the same as a csv file except that the doubles can be separated by any delimiter rather than just commas. Delimiters can be characters such as exclamation points, letters, or even numbers. Remember that the delimiter is always considered a string even if it is a number. Once again, there are two function you need to know: arr = dlmread(filename, delimiter) Unlike with csv files, MATLAB does not automatically know what character is being used as the delimiter in a text file; you will therefore need to specify the delimiter in string format as a second input. If you don't feel like including the second input, MATLAB will attempt to guess the delimiter for you; it likes to choose things like commas and spaces. You can also write delimited files just like csv files; the only difference is that you must now specify the delimiter you want MATLAB to use. dlmwrite(filename, array, delmiter) Reading and Writing Excel Spreadsheets: Peforming tasks on excel spreadsheets is easily the most useful application of high level file IO, which is why most homework and test problems focus on this topic specifically. [num, text, raw] = xlsread(filename) The function to read in excel documents has three outputs instead of one. Although the names you assign them do not matter, the standard convention in CS 1371 is to use the names num, text, and raw. Obviously, MATLAB will always produce the same outputs in the same order, so knowing the order of the outputs is very important. The first ouptut, num, finds all cells in the spreadsheet that contain numbers and turns them into an array of doubles, much like csvread(). MATLAB finds the smallest rectangle of cells that includes all numbers in the spreadshett and forms them into an array. If any cells in the rectangle contain non-numbers or are empty, MATLAB pads the empty space with NaN, which stands for "Not a Number." The seond output, text, finds all the words (non-numbers) in the spreadsheet and formats them into a cell array of strings in the same way, creating the smallest rectangle possible. Empty cells and cells containing numbers are padded with empty strings. The third output, raw, takes the entire spreasheet and turns it into a cell array. Empty spaces are padded with cells containing NaN. The most important things to remember are the respective data types of the three outputs. Num is an array of doubles, whereas text and raw are both cell arrays. When performing numerical calculations, it is often easier to use num; the drawback is that num is not necessarily the same size as the spreadsheet itself. Raw is by definition the same size but carries the drawback of being a cell array. When solving problems, cho Given the spreadsheet "people.xls" [num, text, raw] = xlsread('people.xls') num = 192020 text = {′𝑁𝑎𝑚𝑒′′𝐾𝑒𝑣𝑖𝑛′′𝐿𝑢𝑐𝑦′′𝐵𝑟𝑎𝑛𝑑𝑜𝑛′′𝐴𝑔𝑒′′′′′′′′𝑀𝑎𝑗𝑜𝑟′′𝐶ℎ𝐵𝐸′′𝑀𝑎𝑛𝑎𝑔𝑒𝑚𝑒𝑛𝑡′′𝑀𝐸′} raw = {′𝑁𝑎𝑚𝑒′′𝐴𝑔𝑒′′𝑀𝑎𝑗𝑜𝑟′′𝐾𝑒𝑣𝑖𝑛′[19]′𝐶ℎ𝐵𝐸′′𝐿𝑢𝑐𝑦′′𝐵𝑟𝑎𝑛𝑑𝑜𝑛′[20][20]′𝑀𝑎𝑛𝑎𝑔𝑒𝑚𝑒𝑛𝑡′′𝑀𝐸′} You can also write arrays and cell arrays into excel spreadsheets. The function name is pretty obvious. xlswrite(filename, arr) And that's basically it for high level file IO. I'll quickly recap the six functions before moving onto example problems. arr = csvread(filename) csvwrite(filename, arr) arr = dlmread(filename, delimiter) dlmwrite(filename, arr, delimiter) [num, text, raw] = xlsread(filename) xlswrite(filename, arr) Write a function Haggai that takes in the name ofan excel document containing information about a footrace in the following format. The document may have any number of rows but will always contain three columns with the following column headers: The function should read in the spreadsheet and add an additional column called "Result" as the fourth column. This column contains the final position of each competitor based on his total time. The function should also add an additional row to the end of the spreadsheet. The first column in this row will be the string "Fastest Lap", and the second column will contain the overall fastest lap in the race. The function should write the resultant cell array to an excel file. The filename should be the input filename with "_edited" appended to the end. The final output will look like: function Haggai(fn) [num, ~, raw] = xlsread(fn); % Reading in the file is usually the first step. totals = num(:,end); %For the first step, we're only interested in the total time of each %competitor. This is a race, so lower % total times will receive lower position numbers. To achieve this, we'll use %the second output of the %sort() function, which is the indices used to sort the input. [~, rank] = sort(totals); %Unfortunately, a simple sorting method doesn't quite work with ranking %people, so we have to call the %sort function AGAIN on the indices. I'll overwrite both variables from the %previous function since we %won't be using them anymore. [~, rank] = sort(rank); %Now we have a column vector called index that contains the final rank of %each competitor. To %concatenate this onto the raw spreadsheet data, we have to convert it to %type cell. %index = {index} will put the entire vector inside a SINGLE cell, which is %unfortunately not what we want. %We need to create a vector of cells, each containing one number from our %index vector. Luckily, %there's a MATLAB function that does just that. rank = num2cell(rank); %Now we need to concatenate rank onto the string 'Result'. Since we're concatenating cells, both %elements must be of type cell. We therefore enclose the string in curly brackets before concatenating. column = [{'Result'}; rank]; %We're finished with the last column, so we can add it onto the raw %spreadsheet data. raw = [raw, column]; %Now we just have to determine the fastest lap and perform the same %algorithm. Remember that we're %adding a row instead of a column, so horizontal and vertical concatenations %will be reversed. fastest_lap = min(num(:,1)); %We can't concatenate this time because the dimensions are not consistent, so %we'll use MATLAB's %indexing out of bounds trick. MATLAB will pad the remaining spaces with %empty cells. raw(end+1,1) = {'Fastest Lap'}; raw(end,2) = {fastest_lap}; %Now all we have to worry about is writing the array to the correct filename. %Simply appending %"_edited" onto the end will produce something like "race.xls_edited", which %is not a valid filename. %The ".xls" part must come last. There are probably a dozen ways to do this. %Here's an elegant one. fn2 = sprintf('%s_edited.xls', strtok(fn, '.')); %You can also use find() to locate the period. xlswrite(fn2, raw) end Useful Functions: · num2cell(arr)—converts an array of doubles into a cell array where each cell contains one double · cell2mat(ca)—converts an array of cells containing doubles into an array of doubles · [sort, index] = sort(vec)—always important for sorting

Linspace ():

If you absolutely must include both the start and stop values or are interested in generating a vector of a particular length, you can use the linspace() function. Linspace() takes in a start value, a stop value, and the desired length of the output vector (NOT a step size) and produces a vector of linearly spaced numbers between the start and stop values. The start and stop value are guaranteed to be included, and the space between any two adjacent numbers is always equal. However, you will probably end up with some weird fraction as your step size. If you do not input a desired length, MATLAB will use the default value of 100. linspaceVec = linspace(start, stop, length);

Masking

Indexing with logicals is very different from indexing with doubles. The position numbers of values being indexed are represented by the values of double indices and the position numbers of logical indices. Thus, a true at position three in a logical collection will index the element in position three of the collection being indexed. The index may be shorter than the vector being indexed, but not longer. For some reason, logicals can even be used to index other logicals. For some reason, this is known as masking. vec1 = [1 3 5 3 9]; vec1(vec1==3) ans = [3 3] vec1(vec1 <= 5) ans = [5 9] vec1(true false true) ans = [1 5] Masking can be used with even more precision using and (&) and or (|). These can be used to combine collections of logicals to form a final index representing all of them. Just remember these seemingly random rules: 1. An "and" statement is only true if all of the elements are true. 2. An "or" statement is only false if all of the elements are false. When multiple logical collections are combined using & or |, each element in the collections is compared individually to the corresponding elements in the other collections. This strategy can be used to make a single index that matches many different parameters. vec1 = [1 3 5 7 9]; vec1 >1 & vec1 <= 7 ans = [3 5 7] [true false true] | [false false true] ans = [1 0 1] (true | false) & (false & true) ans = 0

Section Seven: Iteration

Iteration is a fancy MATLAB word for loops, which is a fancy computing word for running a single code block multiple times. Loops are reasonably difficult to understand because, unlike many other coding tools, they are not intuitive. Whereas you would tend to focus on the whole problem to find all solutions at once, MATLAB can look at every possible solution individually. Consider a problem asking you to solve a fourth-order polynomial equation for all real zeros. One approach would be to algebraically or graphically find the solutions (all at once); another approach would be to try plug numbers into the equation until you find all four solutions. Loops allow you to implement the latter method, typically called a "brute force" approach. There are two types of loops, for loops and while loops. Technically, for loops are unnecessary because all for loops can be rewritten as while loops. Paradoxically, students almost never resort to using while loops because they are slightly more difficult to understand For Loops: All for loops are written in the following basic format: for i = <vector> <code block> end When MATLAB reaches the loop, it will automatically set i equal to the first value in the vector, henceforth called the iteration paramater. When it reaches the end of the loop, namely the word "end", MATLAB returns to the first line and changes the value of i to the next value in the vector. This process continues until there are no values remaining for i to assume, at which point MATLAB terminates the loop and reads the rest of your code. Determining the first line is generally the most complicated part of writing a loop. The parameter you set determines how many times the loop will run. Thus, the primary drawback of using for loops is that you must be able to predetermine how many times to iterate. You will generally use the variable i as an index that changes for each iteration. There are two basic strategies: 1. Set i equal to a range of values using the colon operator. for i = 1:10 for i = 1:length(variable) 2. Set i equal to a predetermined or inputted vector. People usually forget that the vector can be ANYTHING, not just a range of values with step size 1. MATLAB will still iterate a number of times equal to the length of the vector, but i will automatically assume values from the vector itself rather than indices. for i = vec I always use the variable i when implementing for loops because that's what my TA used. However, use whatever variable system makes sense to you. They best way to learn loops is by looking at examples. Write a function sumVec that takes in a vector and outputs the sum of its elements using iteration. function out = sumVec (vec) out = 0; for i = 1:length(vec) out = out + vec(i) end end However, this solution has an unnecessary complication. I deliberately ignored the more sensible approach of simply setting i equal to the vector itself. function out = sumVec (vec) out = 0; for i = vec out = out + i end end Write a function compareVec that takes two vectors and outputs a vector of all elements that appear in both vectors in the same position with the same value. Any problem that asks you to build an output vector inside a loop will have a solution in the following format: out = []; for i = <vector> if <logical expression> out(end+1) = <whatever your output should contain> end end The idea is to initialize the output as an empty vector OUTSIDE the loop and build it element-by-element INSIDE the loop. By indexing the vector at position end+1, we continually increase the size of the output vector by adding elements onto the end. A simple assignment statement (out = i) would overwrite the current output variable every time the loop is run. Returning to the compareVec problem: function out = compareVec (vec1, vec2) out = []; L = length(vec1); if length(vec2) < length(vec1) L = length(vec2); end % We must first determine the length of the shorter vector so we know how %many times to iterate. %Further iteration will result in indexing out-of-bounds. for i = 1:L if vec1(i)==vec2(i) out(end+1) = vec1(i); %We could also tack on values to the end by concatening the current vector %with the new value. %out = [out, vec1(i)]; end end end Loops placed inside other loops are called nested loops. Nesting loops allows you to iterate over multiple parameters simultaneously. As a final example, we will consider a case that cannot be solved with only a single loop. Write a function compStr that takes in two strings of equal length and returns the largest set of consecutive letters that appear in both strings at the same position, disregarding case. compStr('henceforth, 'heraldrth') = 'rth' function out = compStr(str1,str2) out = ''; %Once again we're building an output element-by-element, so we have to initialize it OUTSIDE the loop. for i = 1:length(str1) for j = i:length(str2) %If j is less than i, MATLAB will waste time comparing nonexistent ranges like str(4:3). Since str1 and str2 %must be of equal length, we could have used the length of str1 instead. if strcmpi(str1(i:j), str2(i:j)) && j-i+1 > length(out) %We compare each range of values from str1 with the equivalent range from str2. Unless the match is %longer than the ones we've already found, it is discounted. out = str1(i:j) end end end end While Loops: All while loops look like this: while <logical expression> <code block> end MATLAB first evaluates the logical expression and runs the loop until the expression becomes false. Thus, you must have something inside the loop that changes the outcome of the logical expression. Otherewise, MATLAB will enter an infinite loop that can only be terminated using control+c. Although there is no iteration variable associated with while loops, all for loops can be rewritten as while loops using a counter variable inside the loop. The idea is to increase the counter's value by one each time the loop is run. Let's rewrite the sumVec function as a while loop. function out = sumVec (vec) num = 1; out = 0; while num <= length(vec) %Don't forget to include the equals sign! out = out + vec(num); num = num + 1; %This line moves the while loop toward the terminating condition. end end However, while loops are usually used for loops in which the number of iterations is impossible to evaluate beforehand. Write a function Gideon that takes in a number. If the number is even, divide it by two; if it is odd, multiply it by three and subtract one. The function should repeat this process until the number equals one (this always happens) and outputs the number of iterations required. function out = Gideon (num) out = 1; while num ~= 1 if mod(num,2)==0 num = num/2; else num = num*3 - 1; end out = out + 1; end end In more colloquial terms, loops are "dead useful." You can solve almost any problem with a well-implemented for loop. Make sure you understand loops, because almost every problem from now on will involve them.

Transposing and Rotating Arrays:

Just as the apostrophe turns row vectors into column vectors, it also transposes the rows and columns in arrays. The first column becomes the first row, the second column becomes the second row, etc. This is not to be mistaken with rotating an array clockwise or counterclockwise, requires both transposition and indexing.

Char() and Double():

MATLAB contains two built-in functions for converting between different data types. double() changes a character string into a vector of each character's representative ascii code; char() converts a vector of doubles into the characters they represent. You can therefore create a vector of ascii codes and use char() to change it into a string.

Introduction: The MATLAB Command Interface

MATLAB is basically just a really complicated program that functions as an extremely powerful calculator. As such, it can perform tasks than most calculators cannot, usually in fractions of a second. However, like all computer programs, MATLAB is incredibly stupid and is only ever as useful as your coding capability allows it to be. Never underestimate how irritatingly picky MATLAB can be about small sections of code. The programmers designed some functions to be flexible with input values, but for the most part they didn't bother making it user-friendly. It is not necessary to actually purchase the MATLAB software to complete this course, although it is probably pretty useful; I do not personally own the software. Many, not all, computers in the library do have it. Additionally, some computer geeks have set up a virtual desktop call Citrix that allows you to access your library desktop from your laptop. Unfortunately, the remote desktop generally runs very slowly and is prone to freezing at frequent intervals. It also likes to give you nonsensical login error messages such as "We are sorry. This desktop has been locked, and only you can use it." Whenever you run MATLAB in the library or from your remote desktop, it will tell you it's "initializing" and then proceed to take an unreasonable amount of time to generate a pointless message about customizing shortcuts. I have yet to find a method for preventing this. The MATLAB screen is divided into a number of sections with specific names and titles. These are important to learn because they make up a large part of the terminology used in the course.

Calling Functions:

Many people become very confused when they actually attempt to use a function they've written. The easiest and most obvious way to remember the format is that you call your own functions in EXACTLY THE SAME WAY as you would call built-in MATLAB functions. Here is a comparison to the built-in min() function. [minimum, index] = min(vector); [distance, speed] = helperExample(length, width, height); Notice that the input and output variable names of the function call above do not match the names given in the function itself. This is because all variables used in a given function are temporary. When you enter the function call above, MATLAB first opens a new command window for the function helperExample. It then sets the values of "length", "width", and "height" equal to "a", "b", and "c" respectively (always in the same order given in the function header). When MATLAB reaches the end of the helperExample function, it closes the new command window and sets whatever values are stored in "out1" and "out2" equal to "distance" and "speed." However, only those final values will be stored in your original workspace. All other variables are deleted as soon as the function call is complete. Let me reiterate: MATLAB will return only the output variables specified in the function header; all other variables are considered temporary. Additionally, each function call opens its own workspace, which does not have access to the variables in any other workspace. Therefore, any values used within a function must be given as inputs. If you do not specify output variables in your function call, the first results will automatically be stored in "ans." Function calls utilize a simple system known as the stack. Basically, the most recent command is executed first in any given situation. In the helperExample function, each function call to confangleNumber is completed (another command window is opened and closed) before the next line of code is executed. Really, the stack concept is straightforward and easy to remember. That's pretty much it for functions. There's really not that much to know. Examples: Let's just take the scripts from section one and turn them into functions. Remember to make your functions easy to understand by naming variables properly. function [radius, surface_area] = circleStuff (volume) radius = (volume.*3./4./pi).^(1./3); surface_area = 4.*pi.*radius.^2; end function y3 = extrapolate (x1, x2, y1, y2) slope = (y2 - y1) ./ (x2 - x1); y_int = y1 - slope .* x1; y3 = 20 .* slope + y_int; end

The Colon Operator:

Many vectors are too large to create manually. To generate sets of evenly incremented numbers, MATLAB uses a colon operator, not to be confused the semicolon used to suppress outputs. The colon operator takes in a start value, a step value, and a final value; it generates a vector of numbers ranging from the start value to the stop value and incremented by the step size. Expressions using the colon operator do not have to be enclosed in brackets. All vectors are of type double. colonVec = start:step:stop If a step size is not specified, MATLAB will use the default step of one. Step sizes can be positive or negative. Any of the three inputs can be substituted for a variable stored in the current workspace. Putting stupid expressions into the colon operator almost never produces an error. Here is a list of references for absurd situations. 1. If the step size is equal to zero, regardless of the other two inputs, produces an empty vector. 2. If the start and stop values are equal, returns a vector containing only that number unless the step value is zero. 3. If the start value is less than the stop value but the step size is negative, produces an empty vector. 4. If the start value is greater than the stop value but the step size is positive, produces an empty vector. Although the start value is always included in the resulting vector, the stop value will only be included if it falls within the exact step size of the value before it. Thus, 0:4:7 produces the vector [0 4], which does not include 7. You must always be careful to set the step value properly if you want the stop value to be included.

Logical Indexing and Masking:

Seriously, it's the same thing. When you need to determine which elements meet multiple overlapping conditions, you can use and (&) and or (|) to combine multiple sets of logicals.

Section Three: Vectors

So far, we have only considered situations that involve working with single values. However, we may wish to operate on large sets of numbers at the same time. In these situations, we utilize vectors, large collections of scalar quantities. As a matter of fact, even single numbers in MATLAB are interpreted as vectors of length one. Vectors are easy to work with and easy to understand.

Logical Indexing:

So far, we have only dealt with data of type double, representing real, measurable numerical values. However, another data type frequently used in MATLAB is type logical. Logical data can only take two forms: true or false. In most cases, the number one represents true, while the number zero indicates false; however, MATLAB actually interprets anything not equal to zero as true, including negative numbers and strings. When using any of the expressions below, keep in mind that the two objects you wish to compare must be dimensionally IDENTICAL. Attempting to compare two vectors of unequal length will produce an error. A logical expression will generate a collection of logical indicating where the statement is true and where it is false (one for true and zero for false). Logical expressions generally involve comparisons and can take numerous forms: · ==, equal to · >, greater than · <, less than · >=, greater than or equal to · <=, less than or equal to · ~=, not equal to The tilde (~) is always used to refer to the word "not." When preceding a logical collection, it changes every true to false and every false to true. Nifty! vec1 = [1 3 5 7 9]; vec1 == 3 ans = [0 1 0 0 0] (logical) vec1 > 3 ans = [0 0 1 1 1

Creating Strings:

Strings are created by enclosing letters, numbers, and symbols in single quotations marks (''). Unlike with creating vectors, you needn't separate the elements with spaces or commas (remember that spaces and commas now count as elements). You can also create empty strings that function just like empty vectors. If you have a string saved as a variable in your workspace, it will have a cute little 'ab' symbol next to it. The class() of a string is 'char.' In fact, the class() function always returns an answer of type char

Logical Indexing with Strings:

Strings can be used in logical expressions much like vectors. The only difference is that you can now make comparisons between characters and doubles. Remember that comparing vectors of different lengths produces an error. It is impossible with strings of unlike lengths as well; there's a special function for that. Logical expressions are very useful for determining capital and lowercase letters and for differentiating between letters and symbols. Once again, you can locate elements that fulfill multiple logical conditions using and (&) or or(|).

Switch Statements:

Switch statements are if statements that determine the output based on the value stored in a defined variable. The terminology is slightly different for no necessary reason. "case" now replaces "elseif," and "otherwise" replaces "else." Once again, you can have as many cases as you want. The first line always reads "switch" followed by the name of the variable you are "switching" over. switch <variable> case <possible value> <code block> case <possible value> <code block> otherwise <code block> end For instance, if you have a string stored in the variable "str," you can use a switch statement to output whether it is four, five, or six. switch num case 'four' out = 4; case 'five' out = 5; case 'six' out = 6; otherwise out = 'Pharaoh'; end Seriously, folks, conditionals are the easiest thing in the world to write. If you encounter a difficult problem involving conditionals, the actual difficulty will come from the other elements and not from forming the conditionals themselves.

Using the Dot with Basic Arithmetic:

The MATLAB notation to add, subtract, multiply, divide, or raise to a power is exactly what you would expect (+, -, *, /, ^). However, MATLAB must have a way of distinguishing between regular arithmetic and special matrix operations. For instance, you can either multiply each element in one matrix by the corresponding element in another or actually perform matrix multiplication using linear algebra. Note: MATLAB uses decimals instead of fractions whenever it encounters a non-integer. To differentiate between the two, MATLAB utilizes a dot (.) system with the symbols *, /, and ^. To perform element by element multiplication, division, or exponentiation, simply add a single period before the arithmetic symbol (.*, ./, or .^). Linear algebra functions are performed whenever the dot is absent and will cause errors if the dimensions of the matrices do not match properly. Note that the dot has no effect on scalar values (5*5 is the same as 5.*5).

Built-In MATLAB Functions:

The designers of MATLAB included hundreds of built-in functions to assist users in writing code. These functions allow you to perform otherwise complex tasks in a single line of code. To call a function, type its name followed by any inputs in parentheses, separated by commas. I will list any useful functions as well as brief descriptions of them in each section of this guide. If you wish to perform a relatively common task and are wondering whether MATLAB has a built-in function, it probably does. Go to Help function browser (shift+F1) and search for the name of the function you are looking for. Function names are generally incredibly obvious, exactly what you would expect them to be. Function names are also case-sensitive. sin() Calculates the sine cos() Calculates the cosine sqrt() Calculate the square root abs() Calculates the absolute value exp() Calculate eⁿ Examples: Input: 5 x = 5 x = 5: Output to Command Window: ans = 5 x = 5 Input: Output to Command Window x = 5 x =5 y =x y = 5 x =6 x = 6 y y = 5 Note that changing the value of x had no effect on y. y = X Error: undefined variable X Remember that variable names are case-sensitive. x = x + 1 x = 7 Write a script that will calculate the radius and surface area of a sphere given a volume of 15. volume = 15; radius = (volume.*3./4./pi).^(1./3); surface_area = 4.*pi.*radius.^2; (The constant π is expressed as "pi" rather than with symbols) Write a script that uses the linear relationship between the points (3,4) and (-2,5) to find the y-value for x = 20. x1 = 3; y1 = 4; x2 = -2; y2 = 5; slope = (y2 - y1) ./ (x2 - x1); y_int = y1 - slope .* x1; y3 = 20 .* slope + y_int;

Indexing Arrays:

The items in arrays are organized based on their location as determined by rows and columns. Both rows and columns begin at one and increase as you move down and to the right, respectively. Elements are indexed by their row numbers followed by their column numbers, with a comma in between. To index all rows or all columns, replace the row or column numbers in the index with a colon symbol. You can also use the keyword "end" to access the final element in a particular row or column, or both if it makes you happy. arr = [1 2 3; 4 5 6; 7 8 9] ans = 123456789 arr(2,3) ans = 6 arr(2,:) ans = [4 5 6] arr(:,2) ans = [2;5;8] arr(end,end) ans = 9

Lower() and Upper():

The lower() and upper() functions take in a string and convert all letters to lowercase or uppercase letters, respectively. Because they ignore special characters in strings, they are generally very useful. Solving Madlib Problems: For some reason, Madlib problems are very popular in string-related drill problems. The difficulty arises from the concept of replacing part of a string with another string of unequal length. Consider the following Madlib sentence: str = 'I can do all things through @ who strengthens me.' A typical problem may ask you to replace the '@' symbol with the word 'Christ'. Unfortunately, simply slicing letters into the original string will overwrite the end of the sentence rather than insert the word in place (just think of the same problem using vectors instead of strings). You must therefore use either strtok() or manual concatenation to accomplish the insertion. Remember that the find() function returns a vector of all true positions, not merely the first one. index = find(str=='@'); index = index(1); str = [str(1:index-1), 'Christ', str(index+1:end)]; OR [A,B] = strtok(str, '@'); str = [A, 'Christ', B(2:end)];

Section Two: Functions

The primary drawback of scripts is their lack of variability; to run a script with different starting values, you must manually change each of the predetermined variables. Additionally, many problems require running the same block of code many times. Using functions allows you to complete such tasks in a more concise, easily understandable, format. A function is simply a script with variable inputs and outputs. You call the function with whatever inputs you wish to use, it does something, and it returns the final result to whatever called it. Once you have written a function, you don't even have to know exactly what it does—just what it takes in and what it regurgitates

Sprintf():

The sprintf() function allows you to create strings containing variables. Consider the following situation: You need to create a string stating how old someone is, but the person's name and age are stored in variables in your workspace. You can either concatenate the string manually or use the sprintf() function. sprintf() takes in a string containing variable markers followed by the parameters you wish to use. The number of inputs will always be equal to one plus the number of variables in the output string. Variable markers are placed using a percent (%) sign followed by a letter designating the type of variable (double or string, usually). Type %d for a double variable and %s for a string. Remember to list the variable names in the same order you used them; you can use the same variable multiple times in the formatted string, but you still have to list it once for each time it is used.

Strcmp() and Strcmpi():

The strcmp() function allows you to compare strings of unequal length. This is important because attempting to use logical expressions to do so produces an error. Strcmp() outputs a logical 1 or 0 representing whether the two input strings are exactly equivalent. Strcmp() is case-sensitive. There is another built-in function, strcmpi(), that performs the same function while ignoring case Strcmp() and strcmpi() can also be used to compare a string with a cell array of strings, in which case they output a vector of logicals.

Slicing Vectors:

The word "slicing" seems to be standard terminology for this course even though it makes no sense to me. Slicing involves replacing some of the elements in one vector with some of the elements in another vector. The most important thing to remember when slicing is to be careful about what you choose to overwrite. To delete elements from a vector, set them equal to empty brackets. Here are the basic forms of slicing: 1. A(index) = B(index) This is the most common form. MATLAB first evaluates B(index), then replaces A(index) with it. The rest of "A" remains unchanged. Produces an error if B(index) and A(index) are not the same length. 2. A(index) = B Replaces the elements in A(index) with whatever is stored in B. Once again, A(index) and B must have identical lengths. 3. A = B(index) This is the mistake many students make when slicing. This overwrites the variable A and sets it equal to B(index). All elements in A are replaced, including the ones outside the range of B, so the lengths can be unequal without producing an error. 4. A(index) = [] Setting anything equal to empty brackets deletes it. This can be used to shorten the length of A or delete all of the elements entirely, leaving A as an empty vector. Contrary to indexing, you can slice elements that are out of bounds of the original vector. If you assign a value to an element that did not originally exist, MATLAB will extend the vector by filling all intermediate positions with zeros. To slice outside the bounds of a vector of unknown length, use addition or multiplication with "end." vec1 = [1 3 5 7 9]; vec2 = [0 2 4 6 8 10]; vec1([1 2 4]) = vec1(3:end) vec1 = [5 7 5 9 9] vec1(1:3) = vec2(end:-1:4) vec1 = [10 8 6 7 9] vec2(2:end) = vec1 vec2 = [0 1 3 5 7 9] vec1 = vec2(1:2:end) vec1 = [0 4 8] vec2([1 4 5]) = [] vec2 = [2 4 10] vec1(end+2) = 6 vec1 = [1 3 5 7 9 0 6] The possibilities are endless... Concatenating Vectors: MATLAB uses square brackets for just about everything. You can also use them to concatenate vectors, or combine multiple small vectors into one large one. Simply create a vector in the standard manner using vectors as the elements rather than scalar values. To concatenate vectors column-wise, separate the different elements with semicolons. vec1 = [1 5 9]; vec2 = [6 8]; bigVec = [vec2, vec1] bigVec = [6 8 1 5 9] colVec = [vec1'; vec2'] colVec = [1; 5; 9; 6; 8]

The Current Directory:

This box is labeled "Current Folder" and is slightly confusing to become accustomed to. MATLAB can only access files and programs that reside in your current directory; if you attempt to run a function or script from a different folder, MATLAB will give you an error message saying that it doesn't exist. It would therefore behoove you to create an organized set of folders and sub-folders for CS 1371, with each homework assignment having its own folder. If you need to access a function from another homework, which will inevitably happen for some of the more difficult problems, simply copy/paste it into the current directory's folder and submit it with your homework problems. To change the current directory, locate the button on the primary toolbar at the top of the screen and to the right of the current folder display. It should look like an ellipsis. Then just navigate to the folder you wish to select and click "OK." I suggest saving your entire CS 1371 folder on your GT Prism drive so you can access it from any computer on campus.

Reshape()

This function allows you to change the number of rows and columns in an array without altering its overall size. MATLAB fills the spaces in the new array in the same order as the original, namely reading down the columns one at a time. Thus arr(4) will be equal to new_arr(4). You probably won't be using reshape() more than once or twice.

The Command Window:

This is the large and obvious block in the middle of your screen labeled "Command Window." It can be used to run individual lines of code or display the progress of a script. Although you'd imagine it must play a very important role in writing codes, it is actually pretty much useless. If you use the command window to run multiple lines of code sequentially and realize you made a mistake somewhere, you have to redo the WHOLE process. The command window will not allow you to edit anything previously entered, and once a variable is overwritten the original value cannot be restored. To enter a command in the command window, simply type it in the little box underneath and pres enter. It is possible to enter multiple lines of code such as loops and conditional statements using shift+enter, but I wouldn't suggest it. You can use the up-arrow to scroll through your most recent commands so you don't have to retype them. If you attempt to do something that MATLAB doesn't like or if there is a typo in your command, MATLAB will make an annoying beeping sound and display a red error message that tells you what the problem is. Learn to fear the error message. At the very bottom-left part of the screen MATLAB will display statuses such as "initializing", "busy", or "ready." If you accidentally run an infinite loop or an extremely long recursive function, you can cancel your last command by pressing ctrl+c. You can enter clc to clear whatever is in the command window at the time.

The Workspace:

This is the little box off to the right labeled "Workspace." Its purpose is to keep track of all the variables and data types you are using. Anytime you save a value to a particular variable or enter any assignment statement, the workspace is automatically updated with the new information. It displays both the name of the variable and its data type (a brief description of data types will be given in section one). If the workspace is becoming too cluttered with useless variables, you can reset it by entering clear in the command window.

Command History:

This little box keeps track of all the commands you have entered since the beginning of the MATLAB session. If you accidentally clear the command window and workspace but still need the information from them, you can access it from command history. Otherwise, you should just pretend it doesn't exist.

Creating Vectors:

To create a vector, simply enclose a list of numbers or variables separated by spaces or commas in straight brackets. Vectors can be of any length, even one or zero. Vectors of length zero, or empty vectors, are usually used to initialize variables that will be filled later. If you want to create a new variable of a non-predetermined length, first initialize it as an empty vector. You can also create column vectors in much the same way. Simply separate all elements with semicolons to indicate that they should be placed on top of each other. MATLAB indexes and slices column vectors in the same way. To convert row vectors from row to column or column to row, transpose them by following them with an apostrophe. The transpose function is not limited to transposing vectors; it actually swaps the rows and columns of any one or two-dimensional collection. vec = [1 2 3 4 5]; vec2 = [6, 7, 8, 9]; emptyVec = []; columnVec = [1; 2; 3; 4; 5]

Indexing Vectors:

To return a particular range of values from a given vector, you can index into it using parentheses. The item in parentheses, or the range you wish to return from the vector, can be either a double or collection of doubles (another vector) representing the positions in the original vector that you wish to return. By using another vector as the index range, you can return the elements in any order or even the same element multiple times. The length of the vector returned will always be equal to the length of the index. Because any index that returns multiple values is by definition a vector, indices easily be generated using the colon operator. Doing so allows you to perform many nifty indexing tricks such as reversing a vector or returning only even-numbered positions. If you wish to index up to the last element in a vector, use the keyword "end." Because MATLAB interprets "end" as a number equal to the length of the vector, you can use subtraction or division to index positions based on the end value. Any attempt to index with a number less than one, a fraction, or a number greater than the length of the vector you're indexing into will produce an error. You will probably lose a majority of the points on homework assignments from the message "Error: Index exceeds matrix dimensions." vec = [1 3 5 7 9]; vec(3) ans = 5 vec([1 4 2 2 3] ans = [1 7 3 3 5] vec(1:2:5) ans = [1 5 9] vec(6) Error vec(1:3:end) ans =[1 7] vec([1:3, end, end-2]) ans = [1 3 5 9 5] vec(round(end/2):end) ans = [5 7 9]

Section Five: Strings

Vectors and arrays are only useful for organizing sets of doubles and logicals. Now, we will be dealing with a new data type called char (short for character). Using characters allows you to set variables and outputs equal to meaningful words and phrases rather than just numbers. A string is a vector of numbers that represent the characters and symbols on your keyboard. MATLAB identifies these number-character combinations based on a predetermined set of conversions called an Ascii Table. The columns labeled "Dec" contain the ascii codes for the corresponding red characters in the columns labeled "Char." For example, the ascii code fThe columns labeled "Dec" contain the ascii codes for the corresponding red characters in the columns labeled "Char." For example, the ascii code for a capital Z is 90. Note that the code for a lowercase letter is exactly 32 plus its uppercase equivalent. The ascii code for a space is 32. The most important thing to remember about strings is that they function exactly like vectors in most scenarios. To better understand the functionality of strings, we'll be looking at a lot of examples.or a capital Z is 90. Note that the code for a lowercase letter is exactly 32 plus its uppercase equivalent. The ascii code for a space is 32.

Section Four: Arrays

While vectors are merely one-dimensional collections of data stored as rows or columns, arrays are two-dimensional collections stored as grids containing both rows and columns. They operate in exactly the same way as vectors except for a few minor differences. Although arrays are supposed to be different from matrices, they're actually not. Arrays can contain doubles, logicals, and various other data types. While MATLAB is capable of storing data in more dimensions than are readily understandable, this course never involves data collections of more than two dimensions, excluding images.

Concatenating Strings:

You only need to worry about concatenating strings horizontally. Technically, they can be concatenated vertically to make freaky string arrays, but doing so is virtually useless. Keep in mind that strings are concatenated just like vectors, so MATLAB will not add spaces to separate words. You can also concatenate strings with doubles since they're virtually the same thing. MATLAB always retains the string format after concatenation.

Useful Functions: Vector Stuff:

· min(x) - returns the smallest element in the collection (Note: if the minimum value occurs multiple times, min() and max() will return only the first instance) · [value, index] = min(x) - returns the smallest element along with its position number · max(x) - returns the largest element in the collection · [value, index] = max(x) - returns the largest element along with its position number · sort(x) - sorts the elements in ascending order · [newX, index] = sort(x) - returns x in ascending order along with a vector containing the position numbers of the original x to which each value corresponds · fliplr(x) - flips x left-to-right · x' - transposes x (row vector ßà column vector) · mod(x,num) - returns the remainder if x is divided by num · round(x) - rounds x up or down · ceil(x) - rounds x up to the next-highest integer if x is fractional · floor(x) - rounds x down to the next-lowest integer if x is fractional · ones(x,y) - creates an array of ones of dimension x,y (Use 1 for x or y to generate vectors) · zeros(x,y) - creates an array of zeros of dimension x,y · true(x,y) - creates an array of logical trues of dimension x,y · false(x,y) - creates an array of logical falses of dimension x,y · sum(x) - computes the sum of x · prod(x) - computes the product of x rand(x,y) - generates an array of dimension x,y of linearly spaced random numbers between 0 and 1 · randn(x,y) - identical to rand() except all values are truly random · find(logical expression) - generates a vector of all indices where the logical expression is true Logical Stuff: · all(x) - true if everything in x is true · any(x) - true if anything in x is true · not(x) - same as ~x · or(x,y) - same as x | y · and(x,y) - same as x & y

Useful Functions:

· ones(x,y) - creates an array of ones of dimension x,y (Use 1 for x or y to generate vectors) · zeros(x,y) - creates an array of zeros of dimension x,y · true(x,y) - creates an array of logical trues of dimension x,y · false(x,y) - creates an array of logical falses of dimension x,y · magic(x)—creates a magic square of dimension x · [row,col] = size(arr)—returns the number of rows and columns in the input array The following functions work differently with arrays than with vectors. Built-in functions generally treat arrays as individual column vectors and express their outputs as row vectors. · [value,index] = min(arr)—returns a row vector of the minimum values in each column. The second output contains the row number of the minimum value in each column · [value,index] = max(arr)—returns a row vector of the maximum values in each column. The second output contains the row number of the maximum value in each column · [sorted_arr,index] = sort(arr)—sorts each column of the array in ascending order from top to bottom. The second output consists of the indices used to sort each column concatenated together as an array · sum(arr)—returns a row vector of the sum of each column in the array · mean(arr)—returns a row vector of the mean of each column in the array To determine the absolute minimum, maximum, sum, or mean of an array, simply call the respective functions twice. · [value, index] = max(max(arr))—returns the absolute maximum of the array along with its column number · [value, index] = min(min(arr))—returns the absolute minimum of the array along with its column number · sum(sum(arr))—returns the overall sum of the elements in the array · mean(mean(arr))—returns the overall mean of the elements in the array I know these explanations can be somewhat confusing, so do yourself a favor and play around with the min(), max(), mean(), and sort() functions for a few minutes. All four frequently appear on homeworks and test problems.