R for-loops for applying a function to a dataframe vector based on the ID of another column

I'm learning R and have ventured into for-loops that I can't find simplified versions of. I have a data set with 82 unique IDs. I have a list of 82 functions, for each ID, that I want to apply over a 2000+ numeric column, but I only want to apply the functions over values that also share the same ID.

I have a data frame similar to this where I want to use the functions to make the prediction:

funclist[["ID1"]](df$num[df$ID == "ID1"])

I know this line of code will give me the predicted values for that specific ID, but I am not sure how to make a for-loop so I don't have to brute force it 82 times.

pred <- numeric()

for (i in 1:length(funclist)) {
 pred <- funclist[[i]](df$num[NatEmb$ID == i])
}    

This resulted in nothing while

pred <- numeric()

for (i in 1:length(funclist)) {
 pred <- funclist[[i]](df$num)
}    

gave a result, but after double checking with the first line of code it did not match the function ID to the ID of the numeric column.

If someone could offer some advise on how to successfully do this, or basic some basic for loop knowledge I am lacking, that would be awesome.

You could use the for loop approach with base R or load an additional package to use vectorization - applying the same operation on a list/dataframe with the magic of tidyverse packages.

And if you are new to R, I would definitely recommend going this route for learning data analysis.

Here's the approach I would take. Many thanks to @DaveArmstrong for the data

library(tidyverse)

# put the list of functions here
funclist <- list(ID1 = function(x){x*2}, 
                 ID2 = function(x){x*3}, 
                 ID3 = function(x){x*4})


tib <- tibble::tribble(
  ~ID,    ~num,   ~pred,
  "ID1",  0.1, NA,
  "ID1",  0.2, NA,
  "ID2",  0.2, NA,
  "ID2",  0.3, NA,
  "ID3",  0.5, NA,
  "ID3",  0.7, NA,
  "ID3",  0.7, NA)

mutate(tib,
       pred = map2_dbl(ID, num, # run over two parallel vectors
                       ~ funclist[[.x]](.y))) # and apply the function
# ID matching vector 1 (.x) to values in vector 2(.y)

#> # A tibble: 7 × 3
#>   ID      num  pred
#>   <chr> <dbl> <dbl>
#> 1 ID1     0.1   0.2
#> 2 ID1     0.2   0.4
#> 3 ID2     0.2   0.6
#> 4 ID2     0.3   0.9
#> 5 ID3     0.5   2  
#> 6 ID3     0.7   2.8
#> 7 ID3     0.7   2.8

^{Created on 2023-08-08 with reprex v2.0.2}

You were on the right track, your loop just needs a bit of tweaking. First, we can make the data:

tib <- tibble::tribble(
~ID,    ~num,   ~pred,
"ID1",  0.1, NA,
"ID1",  0.2, NA,
"ID2",  0.2, NA,
"ID2",  0.3, NA,
"ID3",  0.5, NA,
"ID3",  0.7, NA,
"ID3",  0.7, NA)

I just defined a simple function list so you can see how it works, presumably yours is more complicated than this.

funclist <- list(ID1 = function(x){x*2}, 
                 ID2 = function(x){x*3}, 
                 ID3 = function(x){x*4})

Since you want the values that get propagated through the loop to be IDs (e.g., "ID1", "ID2"), then you need those to be what you loop over. So, instead of looping over 1:length(funclist) you can loop over names(funclist), then the index will be one of the names of the function each time. Inside the loop, you want to change the values of pred but only for the cases with the appropriate ID, you replace just those observations with predictions using the appropriate funclist values and the column num, but again only for the ID in question.

for (i in names(funclist)) {
  tib$pred[tib$ID == i] <- funclist[[i]](tib$num[tib$ID == i])
} 
tib
#> # A tibble: 7 × 3
#>   ID      num  pred
#>   <chr> <dbl> <dbl>
#> 1 ID1     0.1   0.2
#> 2 ID1     0.2   0.4
#> 3 ID2     0.2   0.6
#> 4 ID2     0.3   0.9
#> 5 ID3     0.5   2  
#> 6 ID3     0.7   2.8
#> 7 ID3     0.7   2.8

You could also do this with mutate and rowwise() to call the function on each row individually:

library(tidyverse)
tib %>% 
  rowwise() %>% 
  mutate(pred = funclist[[ID]](num))
#> # A tibble: 7 × 3
#> # Rowwise: 
#>   ID      num  pred
#>   <chr> <dbl> <dbl>
#> 1 ID1     0.1   0.2
#> 2 ID1     0.2   0.4
#> 3 ID2     0.2   0.6
#> 4 ID2     0.3   0.9
#> 5 ID3     0.5   2  
#> 6 ID3     0.7   2.8
#> 7 ID3     0.7   2.8

Or even more efficiently with group_by() and mutate() calling the function using the first value of ID in the group.

tib %>% 
  group_by(ID) %>% 
  mutate(pred = funclist[[ID[1]]](num))
#> # A tibble: 7 × 3
#> # Groups:   ID [3]
#>   ID      num  pred
#>   <chr> <dbl> <dbl>
#> 1 ID1     0.1   0.2
#> 2 ID1     0.2   0.4
#> 3 ID2     0.2   0.6
#> 4 ID2     0.3   0.9
#> 5 ID3     0.5   2  
#> 6 ID3     0.7   2.8
#> 7 ID3     0.7   2.8

^{Created on 2023-08-09 with reprex v2.0.2}