R Factors

Factors

In-class activity 10

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:

Creating vector of your numbers assigning xf as factor of numeric vector -> realize that 12 is only listed once (as level)

x <- c(5,12,13,12)
xf <- factor(x)
xf

[1] 5  12 13 12
Levels: 5 12 13

The distinct values in xf—5, 12, and 13—are the levels here. Let’s take a look inside:

str(xf)

 Factor w/ 3 levels "5","12","13": 1 2 3 2

-> factor’s structure shows three levels

unclass(xf)

[1] 1 2 3 2
attr(,"levels")
[1] "5"  "12" "13"

-> the unclass function allows us see the attributes (levels) and the different levels

length(xf)

[1] 4

Even though there are three levels, the duplicates still make length ‘4’

We can anticipate future new levels, as seen here:

x <- c(5,12,13,12)
xff <- factor(x,levels=c(5,12,13,88))
xff

[1] 5  12 13 12
Levels: 5 12 13 88

-> the level 88 is added even though it is not yet in the x vector

xff[2] <- 88
xff

[1] 5  88 13 12
Levels: 5 12 13 88

Originally, xff did not contain the value 88, 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(25,26,55,37,21,42)
affils <- c("R","D","D","R","U","D")
tapply(ages,affils,mean)

-> the tapply function let’s us see the mean of ages associated with each affils.

Let’s look at what happened. The function tapply() treated the vector (“R”,“D”,“D”,“R”,“U”,“D”) as a factor with levels “D”, “R”, and “U”. It noted that “D” occurred in indices 2, 3 and 6; “R” occurred in indices 1 and 4; and “U” occurred in index 5. For convenience, let’s refer to the three index vectors (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 “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

assigning gender, age, and income vectors to a dataframe d

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

-> gender, age, and income are columns with shown values in dataframe d

new column over25 is added to d: if age is over 25 then 1 else then 0

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

d

confirm that assignment worked

applying tapply:

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

      0         1
F 39050 123000.00
M    NA  73166.67

mean of income is shown for each gender grouped by over 25 or not -> na for m under 25 as there is no data in dataframe that matches

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.

applying split function:

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 dataframe is split into genders and over 25 or not: therefore, the is two groups per gender

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

-> m and f is assigned to vector -> the split is applied and the split groups show the position in the original vector.

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

applying tapply to vector u and a list of two vectors fl -> the length of each group (a or bc) per vector is shown

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.

creating table with fl:

table(fl)

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

there is one header fl.2 with three subheaders fl.1, a, and bc

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.