R Factors

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 vector has been created then vector X has been transformed into a factor named xf.

x <- c(7,23,7,15,7)
xf <- factor(x)
xf

[1] 7  23 7  15 7 
Levels: 7 15 23

As could be seen above there are 3 levels which are the factors, in this case 7,15 and 23. Value 7 is repeated 3 times.

str(xf)

 Factor w/ 3 levels "7","15","23": 1 3 1 2 1

unclass() function returns its argument with its class attribute removed

unclass(xf)

[1] 1 3 1 2 1
attr(,"levels")
[1] "7"  "15" "23"

The factor has 5 elements

length(xf)

[1] 5

New levels can be added to the factor even if the vector does not have this variable yet. In this case factor has level 67 but vetor does not.

x <- c(7,23,7,15,7)
xff <- factor(x,levels=c(7,23,15,67))
xff

[1] 7  23 7  15 7 
Levels: 7 23 15 67

Adding variable 67 to the vector

xff[3] <- 67
x

[1]  7 23  7 15  7

Originally, xff did not contain the value 67, 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(30,77,12,15,24,39)
affils <- c("J","A","J","A","J","P")
tapply(ages,affils,mean)

 A  J  P 
46 22 39 

Tapply() function uses affils vector as a factor with levels “J”, “A” and “P”. Then, numerical values of vector ages has been attributed to it corresponding level of factor affils.In this example “J” occurred in indices 1, 3 and 5; “A” occurred in indices 2 and 4 and “P” in 6.

I three index vectors are refereed as (2,3,6), (1,4), and (5) 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 “J”, “A”, and “P”, 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

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

d

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

d

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

      0         1
F 39050 123000.00
M    NA  73166.67

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.

My Example

My example with more than 2 factors. In this case variables are going to be size, color and prices of T-shirts in a store. Here, the call tapply(x,f,g) might have x as income and f as a pair of factors: one for size and the other coding whether the T-shirt is cheaper or more expensive than 50$. We may be interested in finding mean price, broken down by size and color. If we set g() to be mean(), tapply() will return the mean incomes in each of four subgroups:

• Size L and under 50$ • Size M and under 50$ • Size L and over 50$ • SIze M and over 50$

tshirt <- data.frame(list(size=c("M","L","L","L","S","M"),coolor=c("red","red","blue","purple","purple","purple"),price=c(55,86,33,45,78,20)))

Data frame as been created with color size and price of tshirts in a shop.

tshirt

Lets show the t shirts that costs less than 50$

tshirt$lower50 <- ifelse(d$price < 50,1,0)

Error in `$<-.data.frame`(`*tmp*`, lower50, value = logical(0)) : 
  replacement has 0 rows, data has 6

tapply(tshirt$price,list(tshirt$coolor,tshirt$lower50),mean)

          0    1
blue     NA 33.0
purple 78.0 32.5
red    70.5   NA

Mean values of prices for blue, purple and red t shirts. 0 correspond to the shirts which values is grater than 50dollars while 1 correspond to the shirt which values is lower than 50dollars

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 45650

$M.0
numeric(0)

$F.1
[1] 123000

$M.1
[1] 55000 88000 76500

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.

Indices of the vector elements corresponding to male, female, and infant wanted to be determined. In this example “Female” occurred in indices 2, 3 and 7; “Male” occurred in indices 1, 5 and 6 and “Infant” in 4.

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

My Example, split() function

Function split() outputs the price of each kind of shirt with the condition of being cheaper or more expensive than 50 dollars. For example there is no blue shirt that costs more than 50dollars but there is one which price is 33dollars.

split(tshirt$price,list(tshirt$coolor,tshirt$lower50))

$blue.0
numeric(0)

$purple.0
[1] 78

$red.0
[1] 55 86

$blue.1
[1] 33

$purple.1
[1] 45 20

$red.1
numeric(0)

Working with Tables

To begin exploring R tables, consider this example:

p <- c(66,90,3,56,0,9,-6)
fl <- list(c(7,14,33,33,7,14,33),c("k","j","j","j","k","j","j"))
tapply(p,fl,length)

    j  k
7  NA  2
14  2 NA
33  3 NA

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 p. 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, 7 occurred twice with “k” and not at all with “j”; 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 “j”. The table() function creates contingency tables correctly.

table(fl)

    fl.2
fl.1 j k
  7  0 2
  14 2 0
  33 3 0

The first argument in a call to table() is either a factor or a list of factors. The two factors here were (7,14,33,33,7,14,33) and (“k”,“j”,“j”,“j”,“k”,“j”,“j”). In this case, an object that is interpretable as a factor is counted as one.