Avoiding nested loops but iterate over 2 values using (l)apply? - r

Question

I'd like to get better at writing elegant code in R, and am trying to avoid writing nested loops, but cannot figure out an (l)apply solution to my problem.
I have a set of paired files, each of which has two variables associated with them - a name and a number. The filenames are long, so I'd like to generate a vector of filenames that can then be accessed by my own custom downstream function for reading them into a dataframe, plotting, etc.
For example, the files look like:
5_simulationA.k 5_simulationA.b
10_simulationA.k 10_simulationA.b
5_simulationB.k 5_simulationB.b
10_simulationB.k 10_simualtionB.b
The ".k" and ".b" files are mates of a pair and must stay together for downstream processing.
I could read in these files by writing a nested loop that would look something like,
K_files = c()
B_files = c()
for (i in c(A,B,C)){ # iterate over letter variable
for (n in c(5,10,15)){ #iterate over numbers of the files
k_filename = paste(n, "_simulation", i, ".k")
b_filename = paste(n, "_simulation", i, ".b")
K_files = c(K_files, k_filename)
B_files = c(B_files, b_filename)
}
}
This is of course very ugly and un-R-like. I would love to find a way to do this with the very powerful apply or lapply statements, or any other elegant solutions anyone might have. Thanks!

Answer 1

Base R function outer is meant for this kind of problem.
L <- c("A", "B", "C")
N <- c(5, 10, 15)
f <- function(i, n, e) paste0(n, "_simulation", i, e)
sapply(c(".k", ".b"), function(.e) outer(L, N, f, e = .e))
# .k .b
# [1,] "5_simulationA.k" "5_simulationA.b"
# [2,] "5_simulationB.k" "5_simulationB.b"
# [3,] "5_simulationC.k" "5_simulationC.b"
# [4,] "10_simulationA.k" "10_simulationA.b"
# [5,] "10_simulationB.k" "10_simulationB.b"
# [6,] "10_simulationC.k" "10_simulationC.b"
# [7,] "15_simulationA.k" "15_simulationA.b"
# [8,] "15_simulationB.k" "15_simulationB.b"
# [9,] "15_simulationC.k" "15_simulationC.b"

Answer 2

From OP's example output filenames, it looks like we want all combinations of n and i. expand.grid returns a dataframe of all combinations of ns and is. We could then use apply to loop through its row to generate the filenames:
i <- c("A", "B", "C")
n <- c(5, 10, 15)
combi <- expand.grid(n = n, i = i)
invisible(apply(combi, 1, function(x){
k_filename = paste0(x[1], "_simulation", x[2], ".k")
b_filename = paste0(x[1], "_simulation", x[2], ".b")
print(k_filename)
print(b_filename)
}))
Noticed that I used invisible to suppress the output of apply since we are only interested in the side-effects (read/write files). Alternatively, we can use pwalk from purrr, which takes each column of the same expand.grid dataframe as input and creates the filenames silently:
library(dplyr)
library(purrr)
combi %>%
pwalk(~ {
k_filename = paste0(.x, "_simulation", .y, ".k")
b_filename = paste0(.x, "_simulation", .y, ".b")
print(k_filename)
print(b_filename)
})
Output:
[1] "5_simulationA.k"
[1] "5_simulationA.b"
[1] "10_simulationA.k"
[1] "10_simulationA.b"
[1] "15_simulationA.k"
[1] "15_simulationA.b"
[1] "5_simulationB.k"
[1] "5_simulationB.b"
[1] "10_simulationB.k"
[1] "10_simulationB.b"
[1] "15_simulationB.k"
[1] "15_simulationB.b"
[1] "5_simulationC.k"
[1] "5_simulationC.b"
[1] "10_simulationC.k"
[1] "10_simulationC.b"
[1] "15_simulationC.k"
[1] "15_simulationC.b"

Answer 3

library(tidyverse)
Type = c("A", "B", "C")
Index = c(5, 10, 15)
crossing(Type, Index) %>%
mutate(k_filename = map2_chr(Index, Type, ~paste(.x, "_simulation", .y, ".k", sep="")),
b_filename = map2_chr(Index, Type, ~paste(.x, "_simulation", .y, ".b", sep=""))) -> names
After that, you can access the k_filename or b_filename using pull
K_files <- names %>% pull(k_filename)