R Factors

Julius Schmid

Factors form the basis for many of R’s powerful operations, including many of those performed on tabular data. The motivation for factors comes from the notion of nominal, or categorical, variables in statistics. These values are nonnumerical in nature, corresponding to categories such as Democrat, Republican, and Unaffiliated, although they may be coded using numbers.

Factors and Levels An R factor might be viewed simply as a vector with a bit more information added (though, as seen below, it’s different from this internally). That extra information consists of a record of the distinct values in that vector, called levels. Here’s an example:

x <- c(3,27,3,16,16,25)
xf <- factor(x)
xf

[1] 3  27 3  16 16 25
Levels: 3 16 25 27

The distinct values in xf — 3, 16, 25 and 27 — are the levels here. Let’s take a look inside. For this, we use the structure function str(). If xf were a data frame, str() would return the number of rows and columns, as well as the data type for each column. For a factor input, on the other hand, str() returns the number of different levels and the level names.

str(xf)

 Factor w/ 4 levels "3","16","25",..: 1 4 1 2 2 3

In our case, we have 4 different levels: 3, 16, 25, and 27. The numbers behind the levels indicate which to what level each component belongs. Here, 1 belongs to level “3”, 2 belongs to “16”, 3 belongs to “25”, and 4 belongs to “27”.

We get a similar output by applying the unclass() function. In fact, for the factor xf str() and unclass() return the same values but in a different order.

unclass(xf)

[1] 1 4 1 2 2 3
attr(,"levels")
[1] "3"  "16" "25" "27"

Now let us return the length of xf. We might expect the length to be 4 since we have 4 factor levels.

length(xf)

[1] 6

The output is different from our expectation! The length is 6, which means that duplicates are counted.

We can anticipate new future levels, as seen here:

x <- c(3,27,3,16,16,25)
xff <- factor(x,levels=c(3,16,25,27,59))
xff

[1] 3  27 3  16 16 25
Levels: 3 16 25 27 59

Here, we just added a new level namely 59. Even though 59 does not appear as a component of x, we can still express that x may have contained 59 because it is one of the possible levels.

Another possibility to add the level 59 is by setting the second value in the factor xff to 59. The new level is added automatically. This is done in the following code.

xff[2] <- 59
xff

[1] 3  59 3  16 16 25
Levels: 3 16 25 27 59

Originally, xff did not contain the value 59, but in defining it, we allowed for that future possibility. Later, we did indeed add the value.

Common Functions Used with Factors

With factors, we have yet another member of the family of apply functions, tapply. We’ll look at that function, as well as two other functions commonly used with factors: split() and by().

The operation performed by tapply() is to (temporarily) split x into groups, each group corresponding to a level of the factor (or a combination of levels of the factors in the case of multiple factors), and then apply g() to the resulting subvectors of x. Here’s a little example:

ages <- c(12,16,15,27,21,42,55)
affils <- c("U","D","U","R","R","D","D")
tapply(ages,affils,mean)

       D        R        U 
37.66667 24.00000 13.50000 

Let’s look at what happened. The function tapply() treated the vector (“U”,“D”,“U”,“R”,“R”,“D”) as a factor with levels “D”, “R”, and “U”. It noted that “D” occurred in indices 2, 6, and 7; “R” occurred in indices 4 and 5; and “U” occurred in indices 1 and 3. For convenience, let’s refer to the three index vectors (2,6,7), (4,5), and (1,3) as x, y, and z, respectively. Then tapply() computed mean(u[x]), mean(u[y]), and mean(u[z]) and returned those means in a three-element vector. And that vector’s element names are “D”, “R”, and “U”, reflecting the factor levels that were used by tapply().

What if we have two or more factors? Then each factor yields a set of groups, as in the preceding example, and the groups are ANDed together. As an example, suppose that we have an economic data set that includes variables for gender, age, and income. Here, the call tapply(x,f,g) might have x as income and f as a pair of factors: one for gender and the other coding whether the person is older or younger than 25. We may be interested in finding mean income, broken down by gender and age. If we set g() to be mean(), tapply() will return the mean incomes in each of four subgroups:

• Male and under 25 years old • Female and under 25 years old • Male and over 25 years old • Female and over 25 years old

Let us create a data frame, containing dummy data with the variables gender, age, and income.

d <- data.frame(list(gender=c("M","F","F","M","F","M"),age=c(47,32,21,32,48,24),income=c(55000,88000,32450,33000,123000,45650)))

Let us see what d looks like

d

We observe 6 rows, each containing data for gender, age, and income for an individual person. In the next step, we create a fourth column over25, which is boolean and returns 1 if the person is older than 25, and 0 if not.

d$over25 <- ifelse(d$age > 25,1,0)
d

Only one woman (row 3) and one man (row 6) are not older than 25.

As mentioned above, we apply the tapply function to this data frame, calculating the mean income for each of the four combinations that we listed above (Male and under 25 years old, Female and under 25 years old, Male and over 25 years old, Female and over 25 years old). That means, that we calculate four different means:

tapply(d$income,list(d$gender,d$over25),mean)

      0      1
F 32450 105500
M 45650  44000

Since there is only one row each for Fx0 and Mx0, these are just the income values for row 3 and 6, respectively. Fx1 and Mx1 each calculate the income mean of two individuals (rows 2 and 5 in the first case, and rows 1 and 4 in the second case)

We specified two factors, gender and indicator variable for age over or under 25. Since each of these factors has two levels, tapply() partitioned the income data into four groups, one for each combination of gender and age, and then applied to mean() function to each group.

The split() Function

In contrast to tapply(), which splits a vector into groups and then applies a specified function on each group, split() stops at that first stage, just forming the groups. The basic form, without bells and whistles, is split(x,f), with x and f playing roles similar to those in the call tapply(x,f,g); that is, x being a vector or data frame and f being a factor or a list of factors. The action is to split x into groups, which are returned in a list. (Note that x is allowed to be a data frame with split() but not with tapply().

Let’s try it out with our earlier example.

split(d$income,list(d$gender,d$over25))

$F.0
[1] 32450

$M.0
[1] 45650

$F.1
[1]  88000 123000

$M.1
[1] 55000 33000

The output of split() is a list, and recall that list components are denoted by dollar signs. So the last vector, for example, was named “M.1” to indicate that it was the result of combining “M” in the first factor and 1 in the second.

As another illustration, consider our abalone example from previous in class activitities (2.9.2). We wanted to determine the indices of the vector elements corresponding to male, female, and infant. The data in that little example consisted of the seven-observation vector (“M”,“F”,“F”,“I”,“M”,“M”,“F”), assigned to g. We can do this in a flash with split().

g <- c("M","F","F","I","M","M","F")
split(1:7,g)

$F
[1] 2 3 7

$I
[1] 4

$M
[1] 1 5 6

Let’s dissect this step-by-step. The vector g, taken as a factor, has three levels: “M”, “F”, and “I”. The indices corresponding to the first level are 1, 5, and 6, which means that g[1], g[5], and g[6] all have the value “M”. So, R sets the M component of the output to elements 1, 5, and 6 of 1:7, which is the vector (1,5,6).

Working with Tables

To begin exploring R tables, consider this example:

u <- c(22,8,33,6,8,29,-2)
fl <- list(c(5,12,13,12,13,5,13),c("a","bc","a","a","bc","a","a"))
tapply(u,fl,length)

   a bc
5  2 NA
12 1  1
13 2  1

Here, tapply() again temporarily breaks u into subvectors, as you saw earlier,and then applies the length() function to each subvector. (Note that this is independent of what’s in u. Our focus now is purely on the factors.) Those subvector lengths are the counts of the occurrences of each of the 3 × 2 = 6 combinations of the two factors. For instance, 5 occurred twice with “a” and not at all with “bc”; hence the entries 2 and NA in the first row of the output.In statistics, this is called a contingency table.

There is one problem in this example: the NA value. It really should be 0, meaning that in no cases did the first factor have level 5 and the second have level “bc”. The table() function creates contingency tables correctly.

table(fl)

    fl.2
fl.1 a bc
  5  2  0
  12 1  1
  13 2  1

The first argument in a call to table() is either a factor or a list of factors. The two factors here were (5,12,13,12,13,5,13) and (“a”,“bc”,“a”,“a”,“bc”,“a”,“a”). In this case, an object that is interpretable as a factor is counted as one.