1. Basic Operations

Thus far, we have seen the use of MATLAB as a scientific calculator. However, MATLAB is much more than a calculator, and the main difference is the possibility to use “variables.” In a scientific calculator we can save and recall a single number only. In MATLAB, in contrast (as in other programming languages), we can store and recall virtually an infinity of different values called variables. A variable is a sort of box, having a certain shape, a certain dimension, with a label naming it. In such a box you can put the (virtual) item you need, for example a number, an image, and so on.

Suppose you want to save a number representing your age. You can create your own variable and store it by simply typing the following command:

>> age=22 <ENTER>

The symbol age is the variable name (the box name), which contains the number 22. Each time you recall (type) such a name, the content of the variable is used; in this simple case, it is displayed. Type again the variable name:

>> age <ENTER>

You can define other variables, for example the number of your friends. Just type:

>> Nfriends = 132 <ENTER>

At this stage, you may wonder about the shape of the box or its volume. The answer is not straightforward. However, by typing the whos command, MATLAB prompts all the variables currently active in the working session:

>> whos <ENTER>

The whos command gives you a list of all the variables created in the workspace together with their characteristics. In order to understand the meaning of such characteristics, consider the analogy between variable and box, as presented in the following table:

Note that the variables list obtained using the command whos can readily be seen in the Workspace Window (see Fig. 1.1).

One nice thing that MATLAB does when you create a variable is that it automatically selects the most suitable type of box for the variable. You need, however, to know a few simple rules about variable names:

Try to create the following variables by typing them after the >> prompt followed by Enter: N-friends  =  12, $aDay  =  60, 3rd_classified  =  11. What happens, and why? MATLAB gives you the following error:

Obviously, in these examples we didn’t follow the aforementioned rules (use of the character—and $, beginning the name with a number).

MATLAB has a few predefined variable names. Some of these are presented in the following table:

You can redefine a variable by simply assigning it a new value:

Once you have inserted a new value, you cannot recall the previous one. However, in the special case of predefined variables, you can clear the redefined variable, and the predefined variable is restored. To clear variables you use the command clear followed by the variable name (or a list of them). Let’s try:

>> clear pi <ENTER>

MATLAB doesn’t give you an answer. However, the command has been executed. Type the pi variable again, and MATLAB will return the value of π:

>> pi <ENTER>

The command clear can be followed by the specification all, and all the variables stored in the workspace are deleted. To test whether this is indeed the case, type the whos command:

>> clear all <ENTER>

>> whos <ENTER>

Note that you receive no answer from MATLAB because there is nothing to display. At the same time, you can see that the Workspace Window (Fig. 1.1) is empty.

With variables you can type complex expressions and store the result. Let’s try:

>> number=13; <ENTER>

>> a=14; <ENTER>

>> c=pi*((number+a/2)/10); <ENTER>

MATLAB doesn’t give an answer because you ended the command with the semicolon (;) which prevents the value of number from being echoed on the screen. However, number still has the value 13, as you can see by entering its name without a semicolon (or looking at the Workspace Window):

>> number <ENTER>

>> c <ENTER>

Our first question about matrices is, “What is a Matrix?” We are not talking about the film, the sequels, the comic books, or the video games. For us, a matrix isn’t a complex computer simulation that you have to do battle with to save humanity. However, you can choose to continue to read the book (in analogy to the blue pill in the film that allows you to lead your normal life) to learn how use MATrix LABoratory to create innovative experiments, thereby changing the world with your discoveries.

In MATLAB, a matrix is a rectangular array of numbers, as shown in the following Fig. 1.2.

The horizontal lines of a matrix are called rows, and the vertical lines are called columns. The numbers in the matrix are called entries. A matrix with m rows and n columns is called an m  ×  n matrix. A matrix one of whose dimensions equals one is often called a vector. An m  ×  1 matrix (one column and m rows) is called a column vector, and a 1  ×  n matrix (one row and n columns) is called a row vector.

If you are familiar with the spreadsheet software Excel, you can imagine each Excel worksheet as a matrix, with rows and columns.

Now let’s try to define some matrices and vectors in MATLAB. Type the following statements as written:

>> a=[3,5,7,8] <ENTER>

>> b=  [4;2;7;1] <ENTER>

>> c=  [3, 53,6;12,-93,145;4,7,1;0,-21,12] <ENTER>

>> whos <ENTER>

As you can see, after the command whos, each variable is displayed together with its size expressed in rows × columns. (Note: if you have used other variables previously, your list of variables could be different). Note that a scalar value, like the variable number, can be considered a 1  ×  1 matrix.

Sometimes we need to know the size of the variables only, instead of the full list of their properties. In this case, the function size(c) returns the number of rows and columns of the variable c:

Another useful function is length(c), which returns the length of the vector c. If c is a matrix, the function length returns the number of rows only:

To put data into a matrix, you must type the values within square brackets, separated by spaces or commas for different elements in a row, while the semicolon (;) is used to indicate the end of the row. Note that the number of elements must be the same in each row:

If you have not put the same number of elements in each row, MATLAB displays an error:

As you can see, MATLAB is not a wizard who tries putting the missing element in the right place. MATLAB does not know whether you want to put the element 2 and 3 in the first and second columns or in the second and third columns respectively.

You can use a matrix or a vector to implement another variable. For example, type in the following statements:

>> x = [3 2 1]; <ENTER>

>> y = [6,7,8]; <ENTER>

>> z1 = [x -y]; <ENTER>

>> z2 = [x; -y]; <ENTER>

Can you work out what z1 and z2 will look like before displaying them? In the following table we present other examples showing how to use variables already implemented to create new variables:

If you do not specify any variable content (i.e., any values inside the square brackets), MATLAB creates a variable of size zero with no value, or more precisely, a matrix of dimension 0  ×  0 with no value in it.

>> y = [ ]; <ENTER>

>> whos y <ENTER>

The Workspace Browser in the desktop provides a handy visual representation of the workspace. By clicking a variable in the Workspace Browser, we open the Array Editor, which can be used to view and change values.

The entry that lies in the ith row and the jth column of a matrix is typically referred to as the (i,j), or (i,j)th entry of the matrix. For example, the (3,2) entry of matrix Q in the table above is 1. In mathematical format, it is usually written as Q_3,2, while in MATLAB you can access to the matrix entries in this way:

>> Q(3,2) <ENTER>

Note the use of parentheses. For indexing you use parentheses, whereas to define a matrix, you use square brackets; otherwise, you get an error:

In the following table you can find other examples:

If P and M are two vectors, it is possible to refer to their entries by referencing only their single dimension, i.e., you can type M(3) instead of M(1,3), and N(2) instead of N(2,1).

If you refer to an element in a nonexistent position, MATLAB gives you an alert:

>> Q(3,3) <ENTER>

What happens if you want to address more than one element at time? This is possible in MATLAB using a vector (or a matrix) in the indexing place to express the selected rows or columns:

>> Q([1,3],2) <ENTER>

How many values do you expect MATLAB to display when you type Q([1,3],[1,2]) ? Two or Four? Let’s try:

>> Q([1,3],[1,2]) <ENTER>

The answer is four, because MATLAB shows the values in the positions given by each combination of the specified rows and columns, i.e., Q₁₁, Q₁₂, Q₃₁, Q₃₂.

Now suppose you have a large matrix from which you want to extract elements going from the ith row to the jth row in the second column. MATLAB offers a very efficient way to this, namely the colon (:) operator. Before seeing how it works, let us generate a new matrix:

>> x=[1 2 3; 4 5 6; 7 8 9; 10 11 12; 13 14 15] <ENTER>

Now type:

Note that more than one command has been typed on the first line. This can be done by separating commands with a semicolon. In addition, note that MATLAB displays exactly the values from the second row to the fourth row in the second columns. This is equivalent to:

>> x([2 3 4],2) <ENTER>

As a matter of fact, using the colon operator is equivalent to generating a vector going from a given value to another one, possible using a prescribed increment (step). The rule is:

Type the following commands:

You now have three equivalent ways of accessing the third-row entries of x:

In the last case, you do not need to specify the start and stop values when you use the colon operator. MATLAB assumes that you mean the entire row. Analogously, if you need the first column only, you can type either x([1,2,3,4,5],1) or x([1:5],1) or x(:,1);

By using the colon operator together with the empty array, we are able to delete entire rows or entire columns. For example, to delete the entire second column of x and then its third and fourth rows, type:

>> x([3,4],:) =[ ] <ENTER>

Note that you cannot delete a single entry in a matrix because that would lead to an ambiguity in its dimensions. So a statement like x(1,2)=[ ] returns an error:

We conclude this paragraph by mentioning a way to create a matrix using indexing. In contrast to other computer languages, in MATLAB we do not need to declare a variable (i.e., tell to MATLAB what type of variable, how large it is, etc.) before using it. MATLAB creates the variable on the fly. So if you want to insert the response time to the stimulus number 10, you can simply type:

MATLAB automatically creates the variable called AnsTime and put the number you have entered in position 10. The unspecified values are filled with zeros by default.

There are operations that can be applied to modify the contents of a matrix without changing the number of elements. These operations are matrix addition, scalar multiplication, and transposition. These form the basic techniques for dealing with matrices, as displayed in the following table:

Multiplication of a matrix by another matrix is more complicated. Multiplication of two matrices is well defined only if the number of columns of the left-hand matrix is the same as the number of rows of the right-hand matrix. Matrix multiplication may seem complex, and perhaps you will not use it very often. However, it turns out to be useful when one of the matrices is a vector, so we give you the following definition:

If A is an m  ×  n matrix and B is an n  ×  p matrix, then their matrix product AB is the m  ×  p matrix whose entries are given by the following equation. The equation means that each element of the ith row of A is multiplied successively by each ­element of the jth column of B. In Fig. 1.3 you can see a visual interpretation of the previous equation.

We reiterate that a matrix product can be performed only if the number of columns in the first matrix (A) is equal to the number of rows of the second matrix (B). For example, using the matrices entered in the previous table, it is not possible to perform the product DC (try to verify this with MATLAB):

However, you can compute the product CD. The result is a matrix having the same number of rows as the first matrix (C) and the same number of columns as the second matrix (D). We see, then, that in general, for two matrices CD  ≠  DC, and indeed, one of these products might not even be defined. But even if C and D are square matrices, it is generally the case that CD  ≠  DC:

>> C*D <ENTER>

An element-by-element operation similar to matrix summation is also available in MATLAB. Let’s say that we want to multiply the elements of A in position i,j by the elements of B in the same i,j position using the element-by-element operators, as shown in the following table:

For those who are familiar with matrix equations, MATLAB has a huge number of other possible operations. Here are some of the basic functions: The inverse function inv(A), the determinant function det(A), the eigenvalue function eig(A), the singular value decomposition function svd(A), the LU factorization lu(A).

Solutions:

In this section of the book we illustrate, step by step, a MATLAB program implementing a behavioral experiment together with the graphical interface for running the program and the statistical analysis for analyzing the data. The experiment we are implementing is a classic experiment in audiovisual perception by Sekuler et al. (1997). The effect showed by these authors is one of the most compelling examples of interaction between audition and vision. It can be observed by comparing the post coincidence trajectories of two moving objects. The objects are perceived as bouncing off each other or as streaming through each other according to whether a sound is presented (or not) when the objects overlap during the motion (Sekuler et al. 1997; Watanabe and Shimojo 2001; Remijn et al. 2004; Kawabe and Miura 2006; Kawachi and Gyoba 2006; Zhou et al. 2007; Grassi and Casco 2009, 2010; Grove and Sakurai 2009). The effect is based on a motion display originally proposed by Metzger (1934). Metzger’s display shows two identical objects (e.g., two discs) that move along the azimuth with uniform rectilinear motion and opposite directions: discs start their motion, overlap and stop at the other disc’s starting point with uniform rectilinear motion. This simple two-dimensional display is a complex inverse optics problem for the visual system (Marr 1982). The display is equally representative of two different events in the real three-dimensional world. In both events the two objects are placed at different depths so that the retinal images of both have identical size. In one event, the objects start their motion, overlap (i.e., one object occludes the other), then stream past one another. In the other possible event, in contrast, after the occlusion, the objects reverse their motion and return to their original starting positions. In brief, the motion of the discs is bistable because both the streaming and bouncing percepts are compatible with the proximal stimulus. However, the streaming percept is usually predominant if the motion display is silent, whereas the bouncing is predominant when the sound is presented. We strongly suggest that the reader read the cited paper to have a clearer idea about the experiment we are going to implement in the “brick” section.

Here, we implement the original experiment by Sekuler et al. (1997). The experiment is a 2 (motion type) by 2 (sound condition) experiment. In the experiment, a disc’s motion can be continuous, or it can stop for a certain number of frames when the discs overlap. In addition, the discs’ motion can be accompanied (or not) by a brief sound that is presented when the discs overlap. The subject’s task is to report whether s/he perceived the discs as streaming or as bouncing. Usually, in this type of experiment, the experimenter records the proportion of bounce responses as a function of the various experimental conditions (the number of streaming responses is, of course, the reciprocal of the number of bounce responses).

The experiment by Sekuler et al. (1997) is a classic “fixed stimuli” experiment. In other words, we know before the subject participates in the experiment what and how many stimuli we are going to present.¹ This is an advantage, because we can prepare many things in advance. For example, a wise thing to do in such cases is to write an event table, i.e., a table in which we write the exact experimental condition we are going to present to the subject trial after trial. In the event table all events will be represented in numbers.

In this chapter we limit ourselves to writing few variables that will turn out to be useful later. First of all, let’s write one variable containing the two factors we are manipulating in the experiment. We will symbolize each factor/condition in numbers.

if you visualize the content of this variable, it looks like this:

The left column codes as a number the video display we are presenting (e.g., 1  =  continuous motion; 2  =  discontinuous motion), the right column codes as a number the sound associated with the display (1  =  no sound; 2  =  sound). However, usually in psychological experiments stimuli are presented more than once, i.e., they are presented with a certain number of repetitions (say, 20 times each).

we can now begin to write the event table:

You should repeat the command EventTable  =  [EventTable; conditions]; 20 times (i.e., the number of repetitions) in order to obtain the complete event table. In a later chapter we will show how to generate repetitive commands automatically.

Now let’s add to the left of the EventTable a new column with the trial number (note the use of the apostrophe, which transposes the array we are creating, so that EventTable becomes a matrix of a few columns but several rows, one row for each trial of the experiment):

Now let’s look at the content of the table matrix. At trial number 12, for example, we know that we are going to present the display 2 (the discontinuous motion) together with the sound (i.e., 2). At trial number 37, we will present the display 1 (the continuous motion) and no sound (i.e., 1), and so on. However, in the current experiment, as in the majority of experiments in psychology, we want the stimuli to be randomized within the block of trials the subject performs. In this way, we avoid possible unwanted effects such as the serial effects that could arise if we were using, for example, a fixed sequence of trials. We can do this by shuffling the trial sequence by means of randperm, which is a MATLAB function that generates a random permutation of integers from 1 to n, i.e., the input the user has to pass to the function. (Note that we will transpose the output of the randperm function so that we have an array with one column and several rows.) Now we substitute the trial sequence column by the shuffled trial sequence column:

Now let’s sort the EventTable content by the shuffled trial number in the first column:

If you now echo in the command window the content of the EventTable matrix, you will see that the stimuli presentation list is now nicely randomized.

A part of the commands we have shown will be included in a script that automatically generates the event table in the desired form. This will be shown in Chap. 3.