Using a nested loop

Another option is to loop through both vectors of variables and make all the plots at once. Because we want a plot for each combination of variables, this is a job for a nested loop. This means one map() loop will be nested inside another. I will refer to the first map() loop as the outer loop and the second one as the inner loop.

I’m going to run through the response variables in the outer loop and the explanatory variables in the inner loop. That way I can graph all of the explanatory variables for each response variable before moving on to the next response variable. This puts the output, a nested list, in a logical order.

A nested loop involves more complicated code. It took some effort for me to wrap my head around how to refer to the list element from the outer loop within the inner loop when using the map() formula coding with the tilde (~). I found the answers/comments to this question on Stack Overflow to be helpful.

Since my scatterplot function is so simple I ended up using formula coding for the outer loop and the function as-is in the inner loop. The inner list elements are fed to the first argument of scatter_fun() by default, which works out great since the first argument is the x variable and the inner loop loops through the explanatory variables. The .x then refers to the outer list elements (the response variable names), and is passed to the y argument of the function in the inner loop.

all_plots = map(response,
                ~map(expl, scatter_fun, y = .x) )

To be honest, I think it is fairly hard to follow what the above code is doing. And I’ve found it difficult to use such an approach if adding additional nested loops. At the end of the day, using anonymous functions involves more code but the results may be easier to understand. Well, as easy to follow as nested loops ever are. 😜 Here’s the same plots using anonymous functions in each map() loop.

all_plots2 = map(response, function(resp) {
     map(expl, function(expl) {
          scatter_fun(x = expl, y = resp)
     })
})

The output is a list of lists. Each sublist contains all the plots for a single response variable. Because I set the names for both vectors of variable names, the inner and outer lists both have names. These names can be used to pull out individual plots.

For example, if I want to see all the plots for the grad response variable I can print that sublist by name. (I’m going to display only two of four grad plots here to save space.)

all_plots$grad[1:2]

# $slp

# `geom_smooth()` using formula 'y ~ x'

# 
# $lat

# `geom_smooth()` using formula 'y ~ x'

If I want to print a single plot, I can first extract one of the sublists using an outer list name and then extract the individual plot via an inner list name.

all_plots$grad$long

# `geom_smooth()` using formula 'y ~ x'

I find the names convenient, but you can also extract plots via position. Here’s the same graph, the third element of the third list.

all_plots[[3]][[3]]

# `geom_smooth()` using formula 'y ~ x'

Combining variables for a single loop

Since nested loops can be complicated, another option is to create all combinations of the two input vectors and then loop through those in a single loop. This can be done, for example, using tidyr::expand_grid(). The main thing I like about tidyr::expand_grid() over expand.grid() from base R is the order of the output. Both put the results into a dataset (data.frame or tibble).

Here’s how that would look, putting the response variables first to match the output order above. I’m using tidyr version 1.1.2 here.

resp_expl = tidyr::expand_grid(response, expl)
resp_expl

# # A tibble: 12 x 2
#    response expl 
#    <chr>    <chr>
#  1 elev     slp  
#  2 elev     lat  
#  3 elev     long 
#  4 elev     nt   
#  5 resp     slp  
#  6 resp     lat  
#  7 resp     long 
#  8 resp     nt   
#  9 grad     slp  
# 10 grad     lat  
# 11 grad     long 
# 12 grad     nt

I can now use pmap() from purrr to loop through the rows of this tibble. I have to be careful with my argument order, though, since I have the y variable first in the tibble but it is the second argument in my function.

allplots2 = pmap(resp_expl, ~scatter_fun(x = .y, y = .x) )

I’m not going to print them here, but one minor downside of this approach is that only the first variable name is carried along to the output list. If I wanted to save these plots separately and use both the response and explanatory variable in the file name I’d need to create the file names based on resp_expl. I won’t show this in the next section on saving plots, so here is a quick example of creating basic file names based on both variables.

allplots2_names = pmap(resp_expl, ~paste0(.x, "_", .y, ".png"))
allplots2_names[1:2]

# $elev
# [1] "elev_slp.png"
# 
# $elev
# [1] "elev_lat.png"

Saving all plots to one PDF

If you want to save every plot as a separate page in a PDF, you can do so with the pdf() function. The code below shows an example of how this works. First, a graphics device to save the plots into is created and given a name via pdf(). Then all the plots are put into that device. Finally, the device is turned off with dev.off(). The last step is important, as you can’t open the file until the device is turned off.

This is a pretty coarse way to save everything, but it allows you to easily page through all the plots. I’ve used this method when I had many exploratory plots for a single response variable that I wanted to share with collaborators.

In this example code I save the file, which I name all_scatterplots.pdf, into the working directory.

pdf("all_scatterplots.pdf")
all_plots
dev.off()

Saving groups of plots together

Another option is to save each group of plots in a separate document. This might make sense in a case like this where there are a set of plots for each response variable and we might want a separate file for each set.

To save each sublist separately we’ll need to loop through all_plots and save the plots for each response variable into a separate file. The list names can be used in the file names to keep the output organized.

The functions in purrr that start with i are special functions that loop through a list and the names of that list simultaneously. This is useful here where we want to use the list names to identify the output files while we save them.

The walk() function is part of the map family, to be used when you want a function for its side effect instead of for a return value. Saving plots is a classic example of when we want walk() instead of map().

Combining the i and the walk gives us the iwalk() function. In the formula interface, .x refers to the list elements and .y refers to the names of the list. You can see I create the plot file names using the list name combined with “scatterplots.pdf”, using _ as the separator.

The code below makes three files, one for each response variable, with four plots each. The files are named “elev_scatterplots.pdf”, “resp_scatterplots.pdf”, and “grad_scatterplots.pdf”.

iwalk(all_plots, ~{
     pdf(paste0(.y, "_scatterplots.pdf") )
     print(.x)
     dev.off()
})

Saving all plots separately

All plots can be saved separately instead of combined in a single document. This might be necessary if you want to insert the plots into some larger document later.

We’ll want to use the names of both the outer and inner lists to appropriately identify each plot we save. I decided to do this by looping through the all_plots list and the names of the list via imap() to make the file names in a separate step. This time I’m going to save these as PNG files so use .png at the end of the file name.

The result is a list of lists, so I flatten this into a single list via flatten(). If I were to use flatten() earlier in the process I’d lose the names of the outer list. This process of combining names prior to flattening should be simplified once the proposed flatten_names() function is added to purrr.

plotnames = imap(all_plots, ~paste0(.y, "_", names(.x), ".png")) %>%
     flatten()
plotnames

# [[1]]
# [1] "elev_slp.png"
# 
# [[2]]
# [1] "elev_lat.png"
# 
# [[3]]
# [1] "elev_long.png"
# 
# [[4]]
# [1] "elev_nt.png"
# 
# [[5]]
# [1] "resp_slp.png"
# 
# [[6]]
# [1] "resp_lat.png"
# 
# [[7]]
# [1] "resp_long.png"
# 
# [[8]]
# [1] "resp_nt.png"
# 
# [[9]]
# [1] "grad_slp.png"
# 
# [[10]]
# [1] "grad_lat.png"
# 
# [[11]]
# [1] "grad_long.png"
# 
# [[12]]
# [1] "grad_nt.png"

Once the file names are created I can loop through all the file names and plots simultaneously with walk2() and save things via ggsave(). The height and width of each output file can be set as needed in ggsave().

You can see I flattened the nested list of plots into a single list to use in walk2().

walk2(plotnames, flatten(all_plots), ~ggsave(filename = .x, plot = .y, 
                                             height = 7, width = 7))

Combining plots

Another way to get a set of plots together is to combine them into one plot. How useful this is will depend on how many plots you have per set. This option is a lot like faceting, except we didn’t reshape our dataset to allow the use faceting.

I like the package cowplot function plot_grid() for quickly combining multiple plots into one. A list of plots can be passed via the plotlist argument.

Here’s what that looks like for the first response variable, elev.

cowplot::plot_grid(plotlist = all_plots[[1]])

We can use a loop to combine the plots for each response variable sublist. The result could then be saved using any of the approaches shown above. If you have many subplots per combined plot you likely will want to save the plots at a larger size so the individual plots can be clearly seen.

response_plots = map(all_plots, ~cowplot::plot_grid(plotlist = .x))
response_plots

# $elev

# 
# $resp

# 
# $grad