2. Data Handling

Logical data (or simply logical) represent the logical TRUE state and the logical FALSE state. Logical variables are the variables in which logical data are stored. Logical variables can assume only two states:

There are two ways to create a logical variable. The first is to explicitly declare it using the logical(X) function; this function converts the elements of the array X into logical data types.

>> clear all; ¹

By typing whos at that MATLAB prompt, you can see that Test_Logic_Var is a 1  ×  1 matrix (a scalar value) of logical values. Vector x contains numbers different from 0 and 1. When the logical function is applied to the vector x, the nonzero values are marked as 1, that is, TRUE values.

We can also create logical variables indirectly, through logical operations, such as the result of a comparison between two numbers. These operations return logical values. For example, type the following statement at the MATLAB prompt:

Since 5 is indeed greater than 3, the result of the comparison is true; however, 10 is not greater than 45, and hence the comparison is false. The operator > is a relational operator, returning logical data types as a result.

When a vector or a matrix is involved in a logical or relational expression, the comparison is carried out element by element. Therefore, if we are checking whether the content of an array is greater than 5, the comparison is made for each element of the array, and the resulting logical array has the same length as that of the array we are checking. The following example shows how this works:

Using the command whos you can see that the vectors c and d are logical vectors. They are not considered by MATLAB as numeric vectors but as vectors of logical values.

The following table lists the relational operators used by MATLAB.

Logical operators are useful in different occasions, such as in preliminary data analysis. Let’s say you need to calculate the average of a data set that includes some outliers, and you want to have the average calculated without them. In this case, you can use the logical operators to average only the data you want to include and according to a cutoff value of your choice (later in the text you will see more examples).

MATLAB uses several logical operators such as &, |, and ∼. The following table shows their use by considering the vectors a, b, c, and d implemented above.

In many cases we need to perform multiple comparisons at once. This is, of course, possible in MATLAB, but we need to follow the MATLAB rules if we do not want to get the wrong result. To show this, let’s test whether a variable x falls within the range from 0 to 2. We might be tempted to prompt: 0  <  x  <  2. However, using this syntax leads to an incorrect result. Indeed, if, let’s say, x is equal to 3, hence outside our range, MATLAB returns 1, which is TRUE.

>> x = 3;

Why does MATLAB return an incorrect result? Because MATLAB makes the comparisons in succession. It first compares x with 0, and because 3 greater than 0, the result of the comparison is true, i.e., 1. Then MATLAB compares the result, i.e., 1, with 2. Because 1 is less than 2, the result of the operation is true. So we need to use a different syntax to obtain the correct result. Multiple comparisons like the previous one have to be written in the following way:

Let us see how to use logical values to target different positions in a vector. We have already seen in Chap. 1 that the elements of a vector can be referenced by means of another numeric vector; we can access some of the vector’s elements using another vector to point to the positions we want. For example, if we want the elements in the third and fifth positions of a vector a of size 5, we can use another vector b as an index vector pointing to the positions we need:

When programming, we use logical index vectors in several contexts. Let’s say that we have a numeric vector and we want to store in a second vector only the values outside the range 6–2. We can do so in this way:

d contains those values stored in a that are TRUE according to c. Note, however, that logical vectors, such as c, can be used to index another vector only when their sizes are identical. Indexing through logical vectors is a very practical way to remove elements from a vector. So we can create the vector d with the following simple command line:

Logical indexing is very useful when one variable is used to categorize a second variable. Let’s suppose we have collected some data in the following experiment, which is based on the Posner cueing paradigm (Posner 1980). Subjects are asked to react as fast as possible to the appearance of a target that can appear to either the left or the right of a central fixation point. Before the target appears, a cue indicates its location, but this cue has a limited validity (e.g. 70% of the trials).

The cue’s validity (or invalidity) can be represented with 1s (or 0s) in the CueValidity vector. Subjects’ response times, in seconds are stored in the vector RT. And these are the data we have collected so far:

Response time can be categorized according to cue validity in the following way:

MATLAB has a number of logical functions operating on scalars, vectors, and matrices. Some examples are given in the following table. The examples use the following vectors:

>> d=[ ];

A string is a variable containing characters instead of numbers. Strings can be used to record subjects’ names or any other type of textual information. A string is assigned to a variable by enclosing it within apostrophes as in the following example:

The string ‘Anne’ is composed of four characters, and the variable nameStr is a 1  ×  4 row vector of characters. The second letter of the name can be accessed in the following way:

If you want to include a string containing an apostrophe, the apostrophe must be repeated:

Because strings are vectors, they may be linked with square brackets, e.g.,

Note that we have put a space character between the name and the surname to separate them. The result is a vector of 15 characters: 6 characters belong to the name, 8 to the surname, and 1 for the space.

Now let’s suppose you want to create an array of names, each row for one name. Because names can differ in length, we need to use the char function. Indeed, if we implement the variable NameList in the following way, we get an error.

Function char() overcomes the problem:

MATLAB has many functions for working with strings, which are listed in the following table. Use the string MyString  =  ’Vision Search’, str1  =  ’hello’ and str2  =  ’help’ to get some practice with them:

To create formatted strings there is another useful function: sprintf(format, variables). Let us see an example. Type the following commands:

Note that the three ellipsis points … allow you to continue the command in the next line.

The function sprintf() contains the format argument and some variables. The format argument is a string containing ordinary characters and conversion specifications. A conversion specification controls the notation, the alignment, the significant digits, the field width, and other aspects of the output format. Conversion specifications begin with the % character. There are also special characters beginning with the / character. Some of these are presented in the following table; however, for a complete list of them, refer to the MATLAB help.

Another useful function is input(). It waits for input from the keyboard, ending with the ENTER key. Type the following:

By default, input() takes numbers as its argument. If we need strings instead, we need to add the optional argument ‘s’ to the input call:

NaN means Not a Number. This variable type is used for missing data. For example, let’s suppose you need to calculate the mean of the elements of a vector but there are some missing values:

MATLAB has few built-in functions for working with NaNs. However, not all standard MATLAB functions can deal with NaNs. To overcome this limitation we need to use logical operators. The function isnan(X) finds where the NaNs are. It returns a logical array containing 1s wherever the elements of X are NaNs. To calculate the mean of a vector using the standard mean () function, we need to use the following syntax:

Note that if you don’t use logical operators, the result you get is a NaN:

MATLAB can manage complex variables, that is, variables that are of different types, at the same time. These variables are called structures. A structure collects different types of elements under the same name. The elements are called fields. For example, to store the information about the participant of an experiment, we can create a structure variable called SubjectTest and assign different values to the various fields as follows:

The structure name is SubjectTest, while name, surname, age, TestDone, Response, CorrectConduction, are the fields. Fields are addressed using the structure name followed by a dot and then the field name. Hence, the second element of the Response field can be addressed as follows:

Structure fields are case-sensitive; this means that MATLAB creates additional fields if we do not type the field name correctly. It is also possible to combine structures to create a matrix of structures. This is useful, for example, when you need to save the results of different participants. For example, the data of a second participant can be added to the structure in the following way:

As you can see from the whos command, SubjectTest is a 1  ×  2 row vector of struct:

If you want to address the second element of the matrix, you can type:

As you can see, some fields are empty; this is because they haven’t been filled for the second participant. It is possible to fill them in later. To do this, type:

Let’s see how to access an element of a vector that is a field of a structure while the structure is simultaneously a member of a matrix of structures. To do this, we have to type the structure name, the index of the structure within parentheses, followed by a point and finally the field name within parentheses. For example, let’s suppose you want to display the last of John’s response times:

A cell is a variable containing different types of data; it is therefore similar to a structure, but cells are more general and have notational differences as well. A cell can contain any data type, from a simple number to a structure or another cell. You can have even a cell array, i.e., a matrix in which each element is a cell.

In Fig. 2.1 is reported an example schema which should clarify the concept by showing a 2  ×  3 cell array. In the first row and first column, the cell array contains a matrix of numbers, while in the first row and second column, the cell array contains a structure, and in the second row and second column, the cell array contains another cell array, and so on.

Let’s see how to create cell arrays and how to insert and retrieve data from them. Be aware of the notational differences between simple arrays, such as numeric and character arrays, and cell arrays, because they can be source of confusion (and errors!).

To create a cell array there are two methods, called “Cell indexing” and “Content indexing”:

Here the curly braces { } are on the right-hand side, and indicate the cell contents. This is a cell array of strings, which is different from an array of strings; indeed, strings stored in cell arrays can have different numbers of characters. Let’s add additional values to the cell:

The parentheses on the left-hand side of the assignment refer, in the normal way, to elements in a cell array, while on the right-hand side the curly braces indicate the content of a cell.

Let’s see how content indexing differs from cell indexing.

Here, the index of the cells within curly braces { } and the content are specified in the standard way after the assignment sign.

You can access the content of a cell by indexing:

To access an element of an array stored in a cell you have to concatenate curly braces and parentheses as follows:

The celldisp() function recursively displays the contents of a cell array. The function cellplot draws a visualization of a cell array, as shown in Fig. 2.2. Nonempty array elements are shaded.

We have seen that both structures and cell arrays can contain different element types. The main difference between them is reported in the following table:

We are still in the introductory chapters, and during this brick we will realize a ­program to run a quite complex experiment. In order to use the concepts we have learned so far, for the brick we need to hypothesize that the experiment is over and that the data file has been safely stored onto the hard drive. In the current brick we will see how to analyze the data.

Before showing how to use the concepts learned so far for the current brick, we need to give you some detail about the data file we will write in the successive chapters. Moreover, we have to inform you about how the data will be stored into this data file. At the end of the experiment we will save a tab-delimited text file. This file will be organized in rows and columns. The first row of the file contains the header, that is, a set for strings identifying the content of the column. The data file will contain on the left text data and on the right numeric data. From left to right, the columns of our data file will contain the subject name, the subject sex, a text note about the subject, the subject number, the subject age, the block number, the trial number, the motion condition (coded as 1 for continuous motion, 2 for the stop at overlap), the sound condition (coded as 1 for the no sound condition and 2 for the sound condition), and the subject’s response, which will be coded as 0 (streaming response) or 1 (bouncing response).

The first thing we have to do is to import the data written in the data file into MATLAB. As we have seen, MATLAB offers several command line options to do this. In order to perform this particular operation, a very convenient (and simple) option is that of using the MATLAB import wizard. If you click on the MATLAB file menu you will see the import data function. An alternative way to call the wizard is to type uiimport at the MATLAB prompt. In both cases, MATLAB asks you where the file you want to import can be found. You have now to browse your computer and look for the file. Let’s suppose that the file is placed in the same folder where we have run the experiment. Once you have selected the data file,² you should see a graphical interface similar to the following (Fig. 2.3).

MATLAB shows you a preview of the file content. Click next. At the top of the import wizard interface there are several options you can select. For example, in our case, we need to tell MATLAB that the file content is tab delimited (but MATLAB should recognize this). On the right you can tell MATLAB the number of header rows in the file. Our data file has one header row. In importing this particular data file, MATLAB will store two variables. One cell type variable and one double type variable. The reason is simple: our data file contains numbers as well as strings. MATLAB recognizes the first columns as strings (those containing the subject’s name, sex, and note). However, the successive columns are recognized as numbers (the subject’s age, the subject number, and so on) and are therefore stored into a matrix of type double.

The first thing you may want to do is to have a preliminary look at the data, such as a set of descriptive statistics. For example, we may want to see whether bounce responses are predominant in the sound condition as well as when the discs stop at the overlap point. The following commands are sufficient to highlight the rows where MATLAB can find the conditions under which we presented the sound and where the discs stopped at the overlap:

Note the presence of the % character. It is used for comments in MATLAB when you write an M-script (see Chap. 3). MATLAB takes no action when the % character is encountered, and it ignores everything that follows it.

If we want to compute the mean separately for these four conditions, we need to use the above rows of code when we call for the function mean. In detail, we need to tell MATLAB to calculate the mean of the column in which we have stored the dependent variable (i.e., the last column) and to calculate the mean in particular when the conditions outlined by the independent variables are satisfied. To do the calculation we have to write as follows:

If we substitute the command mean with the command for the standard deviation (i.e., std), we can also obtain the standard deviations of the four conditions. The same command lines can be used as well for other descriptive statistics such as min and max.