MATLAB functions cards

Card Set Information

MATLAB functions cards
2010-03-03 01:52:30

MATLAB functions and their definitions.
Show Answers:

  1. who
    Shows variables that have been defined in this Command Window (just shows the names of the variables).
  2. whos
    Shows variables that have been defined in this Command Window (this shows more information on the variables, similar to what is in the Workspace Window).
  3. clear
    Clears out all variables so they no longer exist.
  4. clear variablenames
    Clears out a particular variable.
  5. abs(variable)
    Absolute value of that number or variable.
  6. fix(variable)
    Round towards zero.
  7. floor(variable)
    Round towards minus infinity.
  8. ceil(variable)
    Round towards positive infinity.
  9. round(variable)
    Round to nearest integer.
  10. sign(variable)
    Returns 1 if number greater than zero; returns 0 if it is zero; returns -1 if less than zero.
  11. rem(num,div)
    Returns the remainder from division (first number divided by the second number).
  12. char, logical, int32, double
    char = used to store single characters or strings; logical = used to store true/false values; int32 = integer with max 32 bits; double = real number, can use floating point.
  13. rand
    Generates a random real number from 0-1.
  14. How to generate a random integer in the range of x-y.
  15. How to create a row vector or column vector
    • Row vec: v = [1 2 3 4] or [1:4]; for steps, use colon operator.
    • Column vec: v = [1;2;3;4]
  16. How to refer to an element in (a) a vector (b) a matrix?
    • a) myvec(element#)
    • b) mymat(row#,column#) - can refer to subsets of matrices (ex: mymat(1:2,2:3)). If a single index is used (ex: mymat(1)), it unwinds the matrix columnwise (goes down row by row until the next column).
  17. How to create a matrix.
    mat = [4 3 1; 2 5 6; 3:5]
  18. zeros(rows, columns) ; zeros(#)
    ones(rows, columns); ones(#)
    Creates a matrix of zeroes (or ones) of the given dimensions; if only one number is given, that will be the number of rows and columns.
  19. length(variable)
    Gives the number of elements in a vector and the length of the largest dimension (either rows or columns) in a matrix.
  20. size(variable)
    Returns the numbers of rows and columns in a matrix (rows first, then columns).
  21. numel(variable)
    Returns the total number of elements in an array (vector or matrix).
  22. variable(end,#)
    end refers to the last element in a vector. vec(end) = vec(length(vec)). In a matrix, it can refer to the last element in a row or column. Ex: mymat(end,1) returns the last element of the first row and first column.
  23. reshape(variable,rows,columns)
    Iterates through the matrix columnwise and returns a new matrix with the new dimensions.
  24. fliplr(variable)
    Flips the matrix from left to right; the left-most column becomes the last column and so forth.
  25. flipud(variable)
    Flips up to down. Works from outsides in. (1st becomes last, 2nd becomes 2nd to last, etc.)
  26. rot90(variable)
    Rotates the matrix counterclockwise 90 degrees. The top-right value becomes the top-left value; last column becomes the first row.
  27. rep

    Creates a larger matrix, which consists of an m x n matrix of copies of the matrix named in the function call. Ex: a 2 x 2 matrix when called in repmat(mat,2,3) becomes a 6 x 4 matrix with repetitions of the original 2 x 2.
  28. Empty vector
    [ ]; a vector that stores no values, created using empty brackets.
  29. script
    A simple computer program in MATLAB, saved as a .m file. To run a script, simply enter the name of the file without the .m extension.
  30. type
    displays the content of a script. Format: type scriptfilename *scriptname without the .m extension.
  31. lookfor
    searches for the H1 line of a function to describe what it does.
  32. input
    • used in an assignment statement, to allow the user to input a value to a variable. Format: variable = input('String to prompt the user: ');. If the input will be a string, add 's' at the end to specify that. Normally the results are suppressed with a semicolon at the end of the assignment statement.
    • If a string input hasn't been specified but the user enters a number, will error. The user must either enter it as a string, or it should be specified in the program that the user will be entering a string.
    • Need separate input statements for each variable assigned.
    • The only formatting allowed in input is the newline character.
  33. disp
    output function, displays the result of an expression or a string without assigning any value to a variable (either a given variable or the default variable ans). disp doesn't allow for formatting, it just does what's in the argument. Ex: disp(6*4) will display 24. Will display matrices or vectors as they are, not unwinding them.
  34. fprintf
    • Displays output and allows for formatting. First you pass a string that will be displayed, inserting placeholders where values will go, and then follow with any variables to be printed.
    • %d = integers
    • %f = floats
    • %c = single characters
    • % s = strings
    • \n = newline character, will move down to the next line.
    • Can specify fieldwidth for formatting as well. If it's a vector, only need one placeholder. Unwinds matrices columnwise.
  35. plot
    • Plots simple 2-d points and either connects them with lines or plots them as individual points. Can format them with strings such as 'r*' (red star) after the x and y vectors have been called in the argument: plot(x,y,'format').
    • To plot more than one point, need to do it in x and y vectors.
    • When x values are indices of the y vector (ex: when x represents time from 1:n), then you can simply plot the y function (plot(y)) and it does the same thing.
    • help plot will display ways to format.
  36. xlabel
    Uses a string as the argument to create a label for the x axis: xlabel('Time')
  37. ylabel
    Uses a string argument to create a label for the y-axis: Ex: ylabel('Temperature')
  38. title
    Uses a string argument to create a title for the graph. Ex: title('Time and Temp')
  39. axis
    One vector is passed when calling the axis function. The first two values are the min and max for the x-axis, the second are the min and max for the y. Ex: axis([1 10 3 8]). Can also customize it to graph: axis([x-2 x+2 y-2 y+2])
  40. clf
    Clears the Figure Window by removing everything from it. Doesn't take any input or output.
  41. figure
    Creates a new, empty Figure Window when called without any arguments. Calling figure(n) where n is an integer can create and maintain multiple Figure Windows; allows to refer to each individually.
  42. hold
    A toggle function; hold on (or just hold) means you freeze the current graph in the Figure Window to superimpose another. hold off will unfreeze it. Or, just by saying hold a second time, it lets go.
  43. legend
    Displays strings passed to it in a legend box in the Figure Window, in order of the plots in the Figure Window. Ex: plotting two y vectors, can create a legend('y1', 'y2').
  44. grid
    Another toggle function, will display gridlines or not. Especially good for 3-D graphs. Grid on/grid off or just call it once (on) or twice (off).
  45. bar
    bar(xvec,yvec) creates a bar chart.
  46. load
    to read files. Use load filename.dat. Can type who to see what was loaded (loads variables into workspace). It only works with matrices, though, so only if there are the same number of values in each line.
  47. save
    used to write data or to append. Format: save filename matrixvariablename -ascii. The matrixvariablename is what your variable name is that you want to store. The filename is what you will store it as. Stores it as a .dat file with the -ascii. If you want to add more to a file (append it), put -append after -ascii. Will only save variables that are scalars, vectors, or matrices; must be of uniform length.
  48. Calling a function
    The name of the function, followed by the arguments in parentheses. Can also specify an output variable you want the result of the function to be saved in. Can pass multiple arguments or specify multiple outputs.
  49. function header
    • The first line of a function. Includes:
    • function [outputargument(s)] = functionname(inputargument(s))
    • *NOTE: the functionname should be what the function itself is saved under.
    • The input and output arguments in the function declaration DO NOT have to be the same as the ones used when it's being called; they should just specify the types of arguments that will be entered. Ex: area(length,width).
  50. xor
    • A logical function; takes xor(A, B) and returns logical true ONLY IF one of the elements, but not both, is nonzero.
    • A = 0, B = 0, xor(A,B) = 0
    • A = 1, B = 0, xor(A,B) = 1
    • A = 0, B = 1, xor(A,B) = 1
    • A = 1, B = 1, xor(A,B) = 0
  51. sind
    Returns the sin of the argument in degrees.
  52. menu
    • Will display a Figure Window with push buttons for the choices. The first string passed is the heading, the rest are the labels. Ex: mypick = menu('Pick one', 'Green', 'Blue', 'Red'); this will store the equivilent numerical value in the variable mypick (1 for green, 2 for blue, etc...).
    • Uses either an if-else or switch statement to take an action based on the button pressed.
  53. isletter
    Returns logical 1 if the argument is a letter of the alphabet or not: isletter('h') = 1. Need to put the argument in string quotes.
  54. isempty
    Returns logical true if a variable is empty, logical false if it has a value, or an error message if the variable does not exist. Will also determine whether or not a string variable is empty (ex: can determine whether or not the user entered a value into an input function).
  55. iskeyword
    Will determine whether or not something is a keyword and if it can be used as an identifier name. By itself (iskeyword), it returns all the keywords in MATLAB.
  56. Relational operators
    • > greater than
    • < less than
    • >= greater than or equals
    • <= less than or equals
    • == equality
    • ~= inequality
  57. Logical operators
    • || or for scalars
    • && and for scalars
    • ~ not
  58. Truth Table for Logical Operators
    • xy-xx || yx&&yxor(x,y)
    • true truefalsetruetruefalse
    • truefalsefalsetruefalsetrue
    • falsefalsetruefalsefalsefalse
  59. if
    • Conditions in if statements use logical expressions (relational expressions). Chooses whether or not another statement or group of statements is executed. Form:
    • if condition
    • action
    • end
    • If the if condition is true, action is executed; if not, not executed.
    • If you just enter a value in the if condition (ex: if 5), then it takes a logical value and says that it's true and executes the action.
  60. if-else
    • Choosing between two statements or sets of statements. Will either execute one or the other. Form:
    • if condition
    • action1
    • else
    • action2
    • end
    • If condition 1 is true, does that. If it's not, goes to else and executes action2. Can nest them, so multiple else statements; that way, can choose between more than two statements.
  61. elseif
    • Way of choosing among many options instead of using nested if-else statement. Form:
    • if condition1
    • action1
    • elseif condition2
    • action2
    • elseif condition3
    • action3
    • else
    • finalaction
    • end
  62. switch
    • Often used in place of a nested if-else statement; used when an expression is tested to see whether it is equal to one of the several possible values. Form:
    • switch switch_expression
    • case caseexp1
    • action1
    • case caseexp2
    • action2
    • case caseexp3
    • action3
    • otherwise
    • action
    • end
    • If there are more than one cases, use curly braces (case {10 9})
  63. elseif clause
    Can use this instead of nesting if-else statements if choosing among more than two actions.
  64. while
    • A conditional loop. The action is executed as long as the condition is true. It must become false for the look to stop; if in an infinite loop, hit Ctrl-C. Format:
    • while condition
    • action
    • pause(0) %just good practice
    • end
    • Can have multiple conditions using if statements.
    • Good for error-checking.
  65. for
    • A counted loop. When number of repetitions is known ahead of time. The loop variable is the one that's iterated through (ex: i). Format:
    • for loopvar = range
    • action
    • end
    • Common uses: calculating running sums and products, printing results of something, creating vectors, etc.
  66. end
    Always the end of a loop.
  67. factorial
    Will find the factorial of any integer: factorial(5) returns 120. Could use a for loop with a running product, but this is easier.
  68. sum
    Can vectorize sums and sum all the elements at once. Ex: sum(vec) will return the sum of all the elements. Operates columnwise and sums each column in a matrix so it returns a vector of all the column sums.
  69. prod
    Can vectorize and multiply all the elements of a vector at once. Ex: prod(vec) returns the product of all those elements. Multiplies the elements in each column (operates columnwise), so returns a vector with products of each column.
  70. cumsum
    • Returns a vector of running sums, so will show what one element is, and then what the next sum is, then the next, etc...
    • Ex: vec = [5 9 4]
    • cumsum(vec)
    • 5 14 18
    • With a matrix, returns a first row with the matrix argument, and then a sum of the values in the first and second rows (for a 2-row matrix).
  71. cumprod
    Returns a vector of the running procuts. The first value is the first element of the vector, followed by the first value the cumprod function returns, then the next, etc. For a matrix, returns a matrix of the first row, then the product of the first and second rows (for a 2-row matrix).
  72. min
    Can find the min of a vector, will find the min value. min(vec) returns the min. Operates columnwise on a matrix, find the min in each column.
  73. max
    Can find the max value in a vector. max(vec). Operates columnwise on a matrix and will find the max in each column.
  74. array operators
    • How to do numerical operations that involve multiplying on entire vectors or matrices. Use the dot operator before:
    • .^, .*, ./, .\
  75. any
    Returns logical true if any element in a vector is logically true, false if not. Ex: vec = [0 1 2 34]; any(vec) = 1.
  76. all
    Returns logical true only if all the elements in a vector are true, false if not. Ex: vec = [0 1 2 3 4]; all(vec) = 0.
  77. find
    Returns the indices of a vecotr that meet some criteria. Ex, to find all the elements in a vector that are greater than five, find(vec>5).
  78. Matrix or/and operators
    Work elementwise: | is or; & is and. The double operators (|| and &&) only work for scalars.
  79. sign
    Finds the sign of each element in a matrix and returns it, either 0, 1, or -1.
  80. header of a function
    • Includes the word function, then any output arguments it might return, the name of the functionw hich ist he same as the M-file it's saved as, the input arguments in parentheses, and a comment that describes what the function does.
    • function [output arguments] = functionname(input arguments)
    • %Comment describing the function
  81. modular program
    A program taht's broekn down into sections and each is implemented as a separate function. The script is the main program that combines and calls all these functions.
  82. subfunction
    These functions can be stored in the same M-file as the primary function. Calling one function calls the other
  83. syntax error
    Mistakes in using the language, like spelling or missing a comma, quotation mark.
  84. Run-time/execution-time error
    Found when a script or function is executing, like attempting to divide by zero. Will generate a warning message in MATLAB. also, attempting to refer to an element in an array that doesn't exist.
  85. Logical error
    Difficult to locate, mistake in reasoning by the programmer, not in the programming language. Ex: dividing instead of multiplying.
  86. breakpoints
    Places to examine varaibles or expressions. Done in the Editor/Debugger or using built-in commands.
  87. dbstop
    • Sets a breakpoint in the specified line. Format:
    • dbstop functionname line#
    • Allows to type variable anmes/expressions to examine their values at that point in the execution.
  88. dbcont
    Continues the execution, goes to the next step.
  89. dbquit
    Quits debug mode.
  90. function stub
    A placeholder ina stub, can help when a script isn't finished yet, so you can keep going through the script despite not knowing everything that goes into it. Consist of the proper function headers, followed by a simulation of what the function will eventually do (ex: it puts arbitrary values in for the output argumetns).
  91. strcat
    Concatenates string vectors horizontally. Ex: first = 'bird'; second = 'house'. strcat(first,second) = 'birdhouse'. Will remove trailing blanks but not leading blanks from strings before concatenating. Just regularly concatenating (newstr=[first second]) will not do that.
  92. strvcat
    Concatenates strings vertically, so it creates a column vector of strings. It will pad the smaller strings with extra blanks so that they both have the same length.
  93. char
    Creates a matrix of characters. Will automatically pad the strings with rows and blanks as necessary sot hat they are all the same length, like strvcat. Ex: greetmat = char('Hello', 'Goodbye'); size(greetmat) = 2 7.
  94. blanks
    Will create a string of n blank characters. (Hard to see!) Best when concatenating strings if you want a number of blank spaces between. Transposing blanks (ex: blanks(5)') will move the cursor down a certain number of lines. Like printing the newline character several times.
  95. sprintf
    Works exactly like the fprintf function, but instead of printing it creaets a string. Can link it to a variable or something and give that a string value; allows for formatting of string variables. Good for prompts, labels, and arguments to functions. Sprintf can also create a string that can be displayed in the input function.
  96. deblank
    Removes blank spaces from the end of a string. Good for de-padding string matrix elements. Removes ONLY the trailing blanks.
  97. strtrim
    Removes both trailing and leading blanks from a string, but not any blanks in the middle.
  98. upper
    Converts a string to all uppercase letters.
  99. lower
    Converts a string to all lowercase letters.
  100. strcmp
    Compares strings, character by character. Returns logical true if the strings are completely identical (must also be the same length), logical false if not the same length or if any of the corresponding characters are not identical. Takes to arguments, the string variables to be compared.
  101. strncmp
    Compares only the first n characters in strings and ignores the rest. The first two arguments are the strings to compare, and the third argument is the number of characters to compare (the value of n). Ex: strncomp(word1,word2,3).
  102. strcmpi
    The same as strcmpi, except it ignores the case of the letters. So, it takes two arguments, the strings to be compared, and returns logical true if they're all the same except for case, and returns logical false if they're not the same size or if the characters don't correspond.
  103. strncmpi
    The same as strncmpi except ignores case. So, it takes 3 arguments, the first two being the strings to be compared, and the third being the number of characters to compare from the beginning of each string.
  104. findstr
    Receives two strings as input arguments, finds all occurrences of the shorter string within the longer, returns the subscripts of the beginning of the occurrences. Ex: findstr('abcde', 'd'); ans = 4. findstr('d','abcde'); ans = 4. findstr('abcdeabcdedd', 'd'); ans = 4 9 11 12. Returns an empty vector if there are no occurrences.
  105. strfind
    Does the same thing as findstr, except the order of thea rguments maeks a difference. The general form is strfind(string, substring); it finds all occurrences of a substring within the string and returns the subscripts. If there are no occurrences, empty vector returned.
  106. delimiter
    A character or set of characters that act as a separator within a string. By default, it is any whitespace character.
  107. strtok
    • Separates strings into two substrings. Receives one string as input, looks for the first delimiter, then returns a token (the beginning of the string up to but not including the first delimiter). Also returns the rest of the string, which includes the delimiter. Assign two output variables to capture both. Can alternate what the delimiters are, though.
    • [token rest] = strtok(string, delimeters) will return a token that is the beginning of the string up to the first character contained within the delimiters string, and ther est of the string. Ex: [token rest] = strtok('hello', 'l'); token = He rest = llo.
    • Leading delimiter characters are ignored.
  108. strrep
    • Finds all occurrences of a substring with a string and replaces them with a new substring. All strings can be any length, and the lengths of the old and new substrings don't have to be the same. The order of the arguments matters:
    • strrep(string, oldsubstring, newsubstring).
  109. date
    Returns the current date as a string.
  110. eval
    Used to evaluate a string as a function. Ex: eval('plot(x)') will evaulate the string 'plot(x)' as a function and do it.
  111. isletter
    Returns logical true if the character is a letter of the alphabet. Goes elementwise for each letter/character in the string. Ex: isletter('a2') = 1 0
  112. isspace
    Returns logical true if the character is a whitespace character. If a string is passed, will return logical true or false for every element.
  113. ischar
    Returns logical true if any array is a character array or logical false if not. Ex: ischar('EK127') = 1; iscar(3:5) = 0.
  114. int2str
    Converts integers into strings.
  115. num2str
    Converts real numbers into strings. If only the real number is passed to the argument, it will create a string that has four decimal places. The precision can be specified in the second argument.
  116. str2num
    Takes a string in which a number is stored and converts it to a double, default 4 decimals. If a string has numbers separated by blanks, it will convert it into a vector numbers, default type double.
  117. cell
    Can be used to preallocate a cell, then can fill in arguments later. Takes 2 arguments, the 2 dimensions. Takes the arguments in parentheses instead of {}, which would normally be used when referring to fields within a cell array.
  118. { }
    Used with cell arrays. For creating cell arrays with known values, referring to individual elements of cell arrays: {#} for vector, {#,#} for matrix. Can assign individual elements values that way as well. cellmat{1,2} = 3.
  119. referring to elements in cell arrays
    • cellmat = {23 'a'; 1:2:9 'hello'}
    • cellmat alone will display the arguments: [ 23 'a' 1x5 double 'hello']
    • cellmat(2) = 1x5 double (operates columnwise)
    • cellmat{2} or cellmat{2,1} = 1 3 5 7 9
    • cellmat{2,1}(4) = 7 (to index into the cell array, use curlies. Parentheses for the element of the vector itself.)
  120. subsets of cell arrays
    • cellvec{2:3} = 1 3 5 7 9, 'a'
    • Indexes a subset of that cell array, individual elements, operating columnwise.
  121. celldisp
    Recursively displays all elements of the cell array in separate lines. Can either specify celldisp(cellmat), which will display elements as cellmat{1,1}, cellmat{1,2}, etc... OR can do: celldisp(cellmat,'newname'), which takes that newname to display: newname{1,1}, newname{1,2}, etc...
  122. cellplot
    Graphical display of the cell array in a Figure Window. Just displays the same information as typing the name of the variable (doesn't show the contents, just the stuff like 1x5 double).
  123. length(cellvec); size(cellvec); cellvec{end}
    • Length will display the number of elements (vector) or the highest dimension (matrix) of a cell array.
    • Size will display the number of rows and the number of columns.
    • End will index the last element of a cell array.
  124. deleting a row or column from a cell array
    • Reference that individual row or column with an empty vector:
    • cellmat(1,:) = []; this deletes the entire first row.
  125. cellstr
    Converts a character array padded with blanks to a cell array in which the trailing blanks have been removed. Basically, takes a matrix or a vector of strings and converts it into a cell array with no blanks.
  126. char
    • Can convert from a cell array to a character matrix. Will also create a character array with each input argument being a separate row: char('a','b','c') = a;b;c padded with any blanks as necessary.
    • cnames = char(names) creates a character matrix out of a cell array.
  127. iscellstr
    Logical true if a cell array is a cell array of all strings, logical false if not.
  128. structure
    A data structure that groups together values that are logically related in what are called fields of the structure. The fields are named, which helps to make it clear what the values are that are stored in the structure. They are not arrays, though, and they don't have elements. Can't loop through the values in a structure as one could do with an array.
  129. hierarchy of structure elements
    • student = the entire data structure, which is a vector of structures
    • student(1) = an element from the vector, which is an individual structure
    • student(1).quiz = the field from the structure, which is a vector of doubles
    • student(1).quiz(1) = an individual double quiz grade.
  130. struct
    Creates a structure. Takes the form: structname = struct('fieldname1',value,'fieldname2',value,etc...)
  131. dot operator to refer to structure fields
    • structname.fieldname = value; can assign values like that to individual fields. With vectors of structures, refer to the specific lines:
    • structname(1).fieldname
  132. rmfield
    Removes a field from a structure and returns a new structure with the field removed, but does not modify the original structure unless the returned structure is assigned to that variable. Ex: rmfield(newpack, 'code'). Gets rid of one of the fields.
  133. isstruct
    Returns logical 1 if it's a structure variable, 0 if not.
  134. isfield
    Returns logical ture if a fieldname as a string is a field in the structure argument, logical false if not. Ex: isfield(package,'cost') = 1.
  135. fieldnames
    Returnst he names of the fields that are contained in a structure variable. It's a cell array because they're all varying lengths. Curly braces used to refer to the elements, then.
  136. nested structures
    • Structures within structures. Ex:
    • lineseg = struct('endpoint1',struct('x',2,'y',4),'endpoint2',struct('x',1,'y',6))
    • OR
    • lineseg.endpoint1.x
    • lineseg.endpoint2.y
  137. fopen
    • Returns -1 if not opened, or any integer value which becomes the file identifier if it's successful. Often store file identifier as fid.
    • Permission strings: 'r' (read); 'w' (write); 'a' (append).
  138. fclose
    Returns 0 if closed successfully, -1 if not.
  139. fscanf
    • Reads formatted data into a matrix using conversion formats like %d. Format: datamat = fscanf(fid,'format',[dimensions]). Dimensions can either be specific, or if you know the number of rows but not the number of columns (this operates columnwise), then can specify inf as the second dimension.
    • Stores values in all the same type, numerical and not characters.
  140. fgetl
    Reads the file on line at a time as a string vector, and deletes the newline character at the end. Done in some form of a loop, whereas textscan/fscanf can get entire data in one go. More control over how the data is read than any other, because only reads one line at a time.
  141. fgets
    Reads strings from a file one line at a time and keeps the newline character at the end. fgets(fid,nchar) allows you to specify how many characters you want.
  142. feof
    Specifies the end of the file, logical true if it's at the end of the file, logical false if not. In a while loop, can do feof(fid) == 0 OR while ~feof(fid) (which means while not equal to the end of the file).
  143. textscan
    Reads text data from a file and stores it in a cell array as opposed to a matrix like fscanf does. That way, differing lengths and retains the individual characteristics instead of converting all to numerical data. Format: cellarray = textscan(fid, 'format'). Allows you to specify what format the cell array fields are. Ex: subjdata = textscan(fid, '%f %c') specifies that on each line there's a float followed by a space followed by a character, and it creates a cell array that's a 1 x 2 with a [double] and [char]. To refer to individual values, index with curly braces and then parentheses: subjdata{1}(2).
  144. fprintf
    Allows writing to files if the file identifier is specified and the file was opened with the permission 'w'. fprintf(fid,'format',variable). Can also be used for appending to the end of a file if it's opened with the permission 'a'.
  145. xlswrite
    Allows writing to a spreadsheet file with the extension .xls. Ex, create a matrix and then use xls('titleofdoc',matrix).
  146. xlsread
    • Reads from a spreadsheet file. Don't need to add the .xls extension because that's the default.
    • matrix = xlsread('datafilename'). If there are more than one kind of value in the spreadsheet (like characters and numbers and strings), can create multiple outputs to capture:
    • [nums, txt] = xlsread('datafilename'); nums will capture into a double vector and txt will capture strings into a cell array. Say the format looked like this for the original spreadsheet: %c %d %s (character, integer, string). [num txt] would capture first the number values and store that, and then all the string values in an r x 3 cell array, because there were 3 columns originally. Because there were only 2 columns of strings, the middle column will be blank. That way, keeps the original format.
  147. anonymous function
    • A simple, one-line function that does not need to be saved as its own .m file, and can instead be saved under its function handle and called within another script or program. Can save it in a MAT file if it's super helpful (save filename or save filename -append).
    • fnhandle = @(arguments) functionbody. Even when an anonymous function takes no input argument, it must still have empty parentheses passed to it: funhandle().
  148. str2func
    Will convert a string to a function handle.
  149. func2str
    Will converrt a function handle to a string. Coudl be used to put the name of the function in a plot, for example.
  150. fplot
    Plots a function between limits that are specified. Format: fplot(fnhandle, [xmin xmax]).
  151. feval
    Will evaluate a function handle and execute the function for a specified argument. format: feval(@sin, argument).
  152. varargin
    A built-in cell array that can be used to store a variable number of input arguments. CELL ARRAY. Use curly braces to refer to any element in varargin.
  153. varargout
    Can be used to store a variable number of output arguments in a cell array.
  154. nargin
    Returns the number of input arguments that were passed to the function. Returns the total number of input arguments, not just the number of arguments in the cell array varargin.
  155. nargout
    Determines how many output arguments expected. Can be called to determine how many output arguments were used to call a function. Doesn't return the number of output arguments in the function header, but the number of output arguments expected from the function.
  156. nested function
    Outer function can have an inner function within it, and every function must have an end statement. A variable in the outer function can be used in the inner.
  157. end (for functions)
    Must have an end statement for nested functions.
  158. recursive function
    • A function that calls itself. The expressions are put on hold with the interruption of the general case of the recursive definition. When you get to the base case, that's evaluated, and then everything else can be evaluated from that point out the first case that was put on hold.
    • There must always be a base case at which recursion ends, otherwise it's infinite recursion.
    • Starts with the base case, and then the rest of the function. Ex:
    • if n == 1
    • facn = 1
    • else
    • facn = n * fact(n-1);
    • end
  159. subplot
    Creates a matrix of plots in the current Figure Window. Form: subplot(r,c,n) where r is the number of rows of figures, c is the number of columns of figures, and n is the figure number (operating rowwise).
  160. barh
    Creates a horizontal bar chart. Groups together the values in each row, so if you pass a matrix to the barh or bar function, it will have one grouping of data that is the first row, and a second grouping that is the second row. Can customize the width by passing the width after the x and y vectors to be plotted. A width of .6 = more space between bars than a width of 1.2 (the bars will overlap).
  161. area
    Draws a plot as a continuous curve and fills in the area under the curve.
  162. stem
    Draws a stem plot.
  163. hist
    • Creates a histogram, uses just one input argument (a vector) and charts the frequency of occurrence of values within a vector. Uses bins to collect values that are in given ranges.
    • hist(vec) will take the values in the vector and put them into 10 bins by default. hist(vec,n) will put them into n bins.
  164. 'stack'
    Stacks rather than groups values, so the y value represented by the top of the bar is the sum of the values from that row.
  165. pie
    • Creates a pie chart. pie(vec) draws the chart using the percentage of each element of vec of the whole. Starts at the top of the circle and goes around counter-clockwise. Can use a cell array to label them.
    • Can explode a pie chart. 2 vectors are passed to the argument. First, a data vector, and second, a logical vector. The data vector has all the values that will create the chart; the logical vector when true will have that element exploded. A third cell array argument can be passed to have labels.
  166. comet
    Shows the plot by showing the first point and the moving to the next point leaving a trail of all the previous points. The end result looks the same as plot(x,y).
  167. movie
    Displays recorded movie frames. The frames are captured in a loop using the built-in function getframe, and then stored in a matrix.
  168. getframe
    Captures frames in a loop and stores them in a matrix for a movie.
  169. plot3
    3-D line plot.
  170. bar3
    3D bar chart. x and y vectors passed to it.
  171. pie3
    Shows data from a vector as a 3-d pie.
  172. stem3
    3-D stem plot.
  173. grid
    Toggles the grid and makes 3-D plots easier to see.
  174. object handle
    Unique real number that is used to refer to the object. Various plot functions return a handle for the plot object, which can then be stored in a variable. Closing a figure window makes the object handle invalid because the plot doesn't exist anymore.
  175. get
    Displays the property of the object, by passing the object handle as the input argument. Shows color, linestyle, linewidth, etc.
  176. set
    Can change any of the properties displayed in the get function. How to call: set(objhandle, 'PropertyName', property value). Ex: to set a line width: set(handle, 'LineWidth', 1.5). They can also be set in the original function call.
  177. mean
    Calculates the arithmetic mean/average. Operates columnwise.
  178. var
    Calculates the variance, which is the sqrt of the standard deviation.
  179. std
    Calculates the standard deviation.
  180. mode
    Displays the most frequently occurring value. If there are more than one, it shows the smallest; if there are none, it shows the smallest value in the entire data set.
  181. median
    Displays the median. Requires sorting the data first, but this function will automatically do that beforehand if data is not sorted.
  182. union
    Gets all the values from two input vector arguments and displays them in one vector, without repeating. Passing extra output arguments allows you to see the indices of these values in the two vectors.
  183. intersect
    Shows the values that appear in both input vectors; can get the indices as well.
  184. unique
    Shows all the values that are unique from a set argument.
  185. setdiff
    The order of the input arguments matters; takes the first vector and then shows all the values that are in the first vector and not in the second vector.
  186. setxor
    Receives two vectors and shows all the values in both vectors that are not in the intersection of the two vectors; basically does what doing setdiff twice would do.
  187. ismember
    Receives two vectors as input arguments and returns logical vector that is the same length as the first argument, containing 1 if the element in the first vector is also in the second, and 0 if not.
  188. issorted
    Returns 1 if sorted in ascending order, 0 if not.
  189. sort
    Sorts in ascending order, columnwise for matrices. If you specify 'descend' as the second argument, it will sort in descending order.
  190. sortrows
    For string variables; it sorts the first element in each row but not the rest of it, so your words stay intact. Just doing sort on a matrix/vector of string variables would sort the entire string in each row.