Apply same function on same object, with different parameters -- the tidy way - r

Question

I would like to apply iteratively the same function (in the example, my_function) to the same object (here, my_matrix) with different parameters (my_parameters) stored in a list, or something similar.
The reprex is:
library(tidyverse)
my_matrix <- replicate(10, sample(1:10, 10, replace = TRUE))
my_parameters <- tibble(value1 = sample(1:10, 5, replace = TRUE),
value2 = sample(2:3, 5, replace = TRUE))
my_function <- function(param1, param2, matrix) {
(matrix + param1) * param2
}
new_matrix <- my_matrix
for (i in seq.int(nrow(my_parameters))) {
new_matrix <- my_function(my_parameters$value1[[i]], my_parameters$value2[[i]], new_matrix)
}
new_matrix
(I guess I could compute everything in one iteration with a clever factorization, but this is just to illustrate the problem.)
Is there a tidy function, like:
magical_function(my_matrix, my_function, my_parameters)
that would do the trick?
So far, I dug into purrr, but accumulate, or similar functions, does not seem to apply here.
Of note, I am aware that factorization does not (directly) apply here, and that could explain why there is no obvious answer here (as far as I know).

Answer 1

Here is an option using tidyverse where we use the reduce2 and pass the matrix (original_matrix) in .init so that it will be used as the first value to start the accumulation. Note that, the ..1, ..2 etc. notation is used when there are more than 2 objects passed into the function. The ..1 signifies the original_matrix, and the other two in the same order as the 'x', 'y' parameters
library(purrr)
reduce2(my_params$x, my_params$y, ~ (..1 + ..2) * ..3, .init = original_matrix)
# [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
# [1,] 656 512 704 464 368 560 560 560 704 368
# [2,] 704 752 560 416 368 752 416 464 608 752
# [3,] 512 560 560 608 416 608 704 320 752 464
# [4,] 704 656 464 752 512 656 752 416 656 416
# [5,] 416 656 320 464 416 464 416 464 368 752
# [6,] 416 416 752 608 656 320 368 320 320 608
# [7,] 464 368 608 416 416 560 464 752 320 368
# [8,] 752 416 704 512 608 368 320 464 608 560
# [9,] 368 560 368 512 464 368 608 512 368 320
#[10,] 560 368 464 560 656 416 704 704 320 464
If we want to check how the values are getting changed in each run, use the accumulate2
accumulate2(my_params$x, my_params$y, ~ (..1 + ..2) * ..3, .init = original_matrix)
data
set.seed(23131)
original_matrix <- replicate(10, sample(1:10, 10, replace = TRUE))
my_params <- tibble(x = sample(1:10, 5, replace = TRUE),
y = sample(2:3, 5, replace = TRUE))

Answer 2

So I've been thinking about this and I'm not sure there's a 'clean' tidy way of doing it. purrr is all about functional programming, which means that any iteration is independent of the other. As you say, accumulate and reduce can't solve this (at least without other type of checks). One way to do this would be to update your desired matrix using <<-. Below is an example that matches your results:
library(tidyverse)
set.seed(23131)
original_matrix <- replicate(10, sample(1:10, 10, replace = TRUE))
my_params <- tibble(x = sample(1:10, 5, replace = TRUE),
y = sample(2:3, 5, replace = TRUE))
# Define the matrix that will be updated in each iteration
my_matrix <- original_matrix
my_function2 <- function(param1, param2) {
# In each iteration, multiply by your params
# and update `my_matrix` in the global environment
# This ensures that in every interation you're getting
# the up to date `my_matrix`.
my_matrix <<- (my_matrix + param1) * param2
my_matrix
}
final_res <- map2(my_params$x,
my_params$y,
my_function2)
final_res[[nrow(my_params)]]
#> [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10]
#> [1,] 656 512 704 464 368 560 560 560 704 368
#> [2,] 704 752 560 416 368 752 416 464 608 752
#> [3,] 512 560 560 608 416 608 704 320 752 464
#> [4,] 704 656 464 752 512 656 752 416 656 416
#> [5,] 416 656 320 464 416 464 416 464 368 752
#> [6,] 416 416 752 608 656 320 368 320 320 608
#> [7,] 464 368 608 416 416 560 464 752 320 368
#> [8,] 752 416 704 512 608 368 320 464 608 560
#> [9,] 368 560 368 512 464 368 608 512 368 320
#> [10,] 560 368 464 560 656 416 704 704 320 464