MATLAB functions cards

Shows variables that have been defined in this Command Window (just shows the names of the variables).

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).

Clears out all variables so they no longer exist.

Clears out a particular variable.

Absolute value of that number or variable.

Round towards zero.

Round towards minus infinity.

Round towards positive infinity.

Round to nearest integer.

Returns 1 if number greater than zero; returns 0 if it is zero; returns -1 if less than zero.

Returns the remainder from division (first number divided by the second number).

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.

Generates a random real number from 0-1.

round(rand*(y-x))-x

• Row vec: v = [1 2 3 4] or [1:4]; for steps, use colon operator.
• Column vec: v = [1;2;3;4]

• 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).

mat = [4 3 1; 2 5 6; 3:5]

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.

Gives the number of elements in a vector and the length of the largest dimension (either rows or columns) in a matrix.

Returns the numbers of rows and columns in a matrix (rows first, then columns).

Returns the total number of elements in an array (vector or matrix).

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.

Iterates through the matrix columnwise and returns a new matrix with the new dimensions.

Flips the matrix from left to right; the left-most column becomes the last column and so forth.

Flips up to down. Works from outsides in. (1st becomes last, 2nd becomes 2nd to last, etc.)

Rotates the matrix counterclockwise 90 degrees. The top-right value becomes the top-left value; last column becomes the first row.

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.

[ ]; a vector that stores no values, created using empty brackets.

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.

displays the content of a script. Format: type scriptfilename *scriptname without the .m extension.

searches for the H1 line of a function to describe what it does.

• 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.

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.

• 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.

• 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.

Uses a string as the argument to create a label for the x axis: xlabel('Time')

Uses a string argument to create a label for the y-axis: Ex: ylabel('Temperature')

Uses a string argument to create a title for the graph. Ex: title('Time and Temp')

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])

Clears the Figure Window by removing everything from it. Doesn't take any input or output.

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.

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.

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').

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).

bar(xvec,yvec) creates a bar chart.

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.

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.

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.

• 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).

• 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

Returns the sin of the argument in degrees.

• 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.

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.

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).

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.

• > greater than
• < less than
• >= greater than or equals
• <= less than or equals
• == equality
• ~= inequality

• || or for scalars
• && and for scalars
• ~ not

• xy-xx || yx&&yxor(x,y)
• true truefalsetruetruefalse
• truefalsefalsetruefalsetrue
• falsefalsetruefalsefalsefalse

• 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.

• 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.

• 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

• 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})

Can use this instead of nesting if-else statements if choosing among more than two actions.

• 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.

• 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.

Always the end of a loop.

Will find the factorial of any integer: factorial(5) returns 120. Could use a for loop with a running product, but this is easier.

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.

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.

• 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).

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).

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.

Can find the max value in a vector. max(vec). Operates columnwise on a matrix and will find the max in each column.

• How to do numerical operations that involve multiplying on entire vectors or matrices. Use the dot operator before:
• .^, .*, ./, .\

Returns logical true if any element in a vector is logically true, false if not. Ex: vec = [0 1 2 34]; any(vec) = 1.

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.

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).

Work elementwise: | is or; & is and. The double operators (|| and &&) only work for scalars.

Finds the sign of each element in a matrix and returns it, either 0, 1, or -1.

• 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

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.

These functions can be stored in the same M-file as the primary function. Calling one function calls the other

Mistakes in using the language, like spelling or missing a comma, quotation mark.

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.

Difficult to locate, mistake in reasoning by the programmer, not in the programming language. Ex: dividing instead of multiplying.

Places to examine varaibles or expressions. Done in the Editor/Debugger or using built-in commands.

• 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.

Continues the execution, goes to the next step.

Quits debug mode.

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).

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.

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.

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.

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.

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.

Removes blank spaces from the end of a string. Good for de-padding string matrix elements. Removes ONLY the trailing blanks.

Removes both trailing and leading blanks from a string, but not any blanks in the middle.

Converts a string to all uppercase letters.

Converts a string to all lowercase letters.

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.

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).

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.

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.

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.

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.

A character or set of characters that act as a separator within a string. By default, it is any whitespace character.

• 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.

• 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).

Returns the current date as a string.

Used to evaluate a string as a function. Ex: eval('plot(x)') will evaulate the string 'plot(x)' as a function and do it.

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

Returns logical true if the character is a whitespace character. If a string is passed, will return logical true or false for every element.

Returns logical true if any array is a character array or logical false if not. Ex: ischar('EK127') = 1; iscar(3:5) = 0.

Converts integers into strings.

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.

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.

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.

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.

• 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.)

• cellvec{2:3} = 1 3 5 7 9, 'a'
• Indexes a subset of that cell array, individual elements, operating columnwise.

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...

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).

• 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.

• Reference that individual row or column with an empty vector:
• cellmat(1,:) = []; this deletes the entire first row.

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.

• 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.

Logical true if a cell array is a cell array of all strings, logical false if not.

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.

• 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.

Creates a structure. Takes the form: structname = struct('fieldname1',value,'fieldname2',value,etc...)

• structname.fieldname = value; can assign values like that to individual fields. With vectors of structures, refer to the specific lines:
• structname(1).fieldname

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.

Returns logical 1 if it's a structure variable, 0 if not.

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.

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.

• 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

• 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).

Returns 0 if closed successfully, -1 if not.

• 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.

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.

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.

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).

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).

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'.

Allows writing to a spreadsheet file with the extension .xls. Ex, create a matrix and then use xls('titleofdoc',matrix).

• 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.

• 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().

Will convert a string to a function handle.

Will converrt a function handle to a string. Coudl be used to put the name of the function in a plot, for example.

Plots a function between limits that are specified. Format: fplot(fnhandle, [xmin xmax]).

Will evaluate a function handle and execute the function for a specified argument. format: feval(@sin, argument).

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.

Can be used to store a variable number of output arguments in a cell array.

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.

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.

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.

Must have an end statement for nested functions.

• 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

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).

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).

Draws a plot as a continuous curve and fills in the area under the curve.

Draws a stem plot.

• 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.

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.

• 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.

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).

Displays recorded movie frames. The frames are captured in a loop using the built-in function getframe, and then stored in a matrix.

Captures frames in a loop and stores them in a matrix for a movie.

3-D line plot.

3D bar chart. x and y vectors passed to it.

Shows data from a vector as a 3-d pie.

3-D stem plot.

Toggles the grid and makes 3-D plots easier to see.

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.

Displays the property of the object, by passing the object handle as the input argument. Shows color, linestyle, linewidth, etc.

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.

Calculates the arithmetic mean/average. Operates columnwise.

Calculates the variance, which is the sqrt of the standard deviation.

Calculates the standard deviation.

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.

Displays the median. Requires sorting the data first, but this function will automatically do that beforehand if data is not sorted.

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.

Shows the values that appear in both input vectors; can get the indices as well.

Shows all the values that are unique from a set argument.

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.

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.

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.

Returns 1 if sorted in ascending order, 0 if not.

Sorts in ascending order, columnwise for matrices. If you specify 'descend' as the second argument, it will sort in descending order.

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.