How to write for loop for sjt.xtab in R, a df of factors?

I'm trying to write a for loop to create tables using sjt.xtab() so it iterates through every variation in a dataframe. Ideally this would be generalizable to all other dataframes too so a function would probably be better.

I have a dataframe called df_mod:

'data.frame':   849 obs. of  17 variables:
 $ amazon       : Factor w/ 4 levels "0","1","2","3": 2 2 2 1 3 2 3 3 2 2 ...
 $ manhattan    : Factor w/ 2 levels "Manhattan","Other": 2 2 2 1 2 2 2 2 2 2 ...
 $ income       : Factor w/ 5 levels "$25-49k","$50 - 74k",..: 2 4 4 1 3 2 3 5 5 2 ...
 $ phone        : Factor w/ 2 levels "0","1": 2 2 2 2 2 1 2 2 2 2 ...
 $ gender       : Factor w/ 2 levels "0","1": 1 1 1 1 1 2 2 2 1 1 ...
 $ age          : Factor w/ 6 levels "18-24","25-34",..: 2 2 3 6 5 6 3 2 3 3 ...
 $ education    : Factor w/ 3 levels "College","Graduate",..: 2 3 3 1 3 1 1 2 2 2 ..

and tried:

xtab_list <- list()

# Iterate through the columns in the dataframe
for (i in 1:ncol(df_mod)) {
  for (j in i+1:ncol(df_mod)) {
    # Calculate the contingency table for each pair of columns
    xtab <- sjt.xtab(df_mod[,names(df_mod)[i]], df_mod[,names(df_mod)[j]])
    # Append the contingency table to the list
    xtab_list[[paste0(names(df_mod)[i], names(df_mod)[j])]] <- xtab
  }
}

and receive this error:

Error in `[.data.frame`(df_mod, , names(df_mod)[j]) :
undefined columns selected

Also tried it without the names(df_mod) but received the same error.

It works when when I write out individual columns so it's not the column type (all factors):

sjt.xtab(df_mod$gender, df_mod$education)

so I'm not sure what I'm doing wrong, especially since it's bad coding to do each one by one and I'd much rather do it once properly. Thank you!

The code in the original post fails to produce expected results due to a subtle error in the line:

for (j in i+1:ncol(df_mod)){ ... }

It executes as "j in i plus (1:ncol(df_mod))." That is, R evaluates the : operator before the binary + operator. This is documented in R: Operator Syntax and Precedence in the R documentation.

What was originally intended would be written as:

for (j in (i+1):ncol(df_mod)){ ... }

For example, when i is 1, the original for() loop for j iterates from 2 to ncol(df_mod) + 1, which points to a nonexistent column.

Example: pairs of columns in mtcars

We can loop through the mtcars data frame to generate pairs of columns that are needed for a set of cross tabs. For now we'll ignore the underlying data types to illustrate how to generate the combinations of columns via a nest of 2 for() loops.

Since a crosstab of a variable with itself is not particularly helpful, we'll end the for(i in ...) loop at ncol(mtcars) - 1.

for(i in 1:(ncol(mtcars) - 1)){
     for(j in (i+1):ncol(mtcars)){
          message(paste("i is:",names(mtcars)[i],"j is:",names(mtcars)[j]))
     }
}

We'll print the last 6 rows of messages to show how the sequence ends.

i is: vs j is: am
i is: vs j is: gear
i is: vs j is: carb
i is: am j is: gear
i is: am j is: carb
i is: gear j is: carb

An Alternate Approach

Another way to solve this problem is to generate all the combinations of the desired variables, and process them in an apply() function.

We'll create a reproducible example with the mtcars data frame.

# categorical variables in mtcars are vs, am, cyl, gear, carb
theColumns <- c("vs","am","cyl","gear","carb")

library(sjPlot)

# generate combinations of the categorical variables for xtabs 
theCombinations <- combn(theColumns,2)

At this point we have a 2 row 10 column matrix that represents the unique combinations of the 5 categorical variables in the mtcars data frame.

theCombinations

> theCombinations
     [,1] [,2]  [,3]   [,4]   [,5]  [,6]   [,7]   [,8]   [,9]   [,10] 
[1,] "vs" "vs"  "vs"   "vs"   "am"  "am"   "am"   "cyl"  "cyl"  "gear"
[2,] "am" "cyl" "gear" "carb" "cyl" "gear" "carb" "gear" "carb" "carb"
>

Next, we'll use lapply() to loop through the matrix and generate the cross tabs, saving them to a list called theTabs.

# for each column in theCombinations, run the xtab 
theTabs <- lapply(1:ncol(theCombinations),function(x,y,z){
     sjt.xtab(z[[y[1,x]]],z[[y[2,x]]])
},theCombinations,mtcars)

The anonymous function within lapply() takes three arguments. The first, x, is the sequence from 1 to ncol() of the matrix containing the pairs of variables for which we will generate 2-way contingency tables. The lapply() function will call the anonymous function ncol() times.

The second argument, y, represents the matrix of column combinations.

The third argument, z represents the data frame where the columns to be tabulated are stored.

Finally, we print the first item in the list.

# print the first table 
theTabs[[1]]

...and the output:

Hmm... those variable labels look a bit funky, so we'll add a var.labels argument to make the output easier to read.

# add some variable labels 
theTabs <- lapply(1:ncol(theCombinations),function(x,y,z){
     sjt.xtab(z[[y[1,x]]],z[[y[2,x]]], var.labels = c(y[1,x],y[2,x]))
},theCombinations,mtcars)

# print the first table 
theTabs[[1]]

...and the output:

Extracting the names of the factor columns in a data frame to use as theColumns is left as an exercise for the reader.