主页 / coding / 问题 / 78876734
Accepted
Mohan
Asked: 2024-08-16 04:25:17 +0800 CST

给定一个向量 v 和 fn f，如何生成矩阵 {v, f(v), f(f(v)), ... f^k(v)}？

  • 772

我有一个向量x和一个函数f。我需要生成一个矩阵，其第一列为v，第二列为f(v)，依此类推，直到最后一列为f^k(v)。在函数式语言中，我可以使用展开操作。我看过purrr备忘单，但没有发现任何类似的东西。

如果您需要一个具体的例子，请采取v = c(1:100)和f = function(x){return (2*x)}——但请不要利用 f^k 在这种情况下恰好具有很好的封闭形式的事实。

4 个回答

  1. Best Answer

    您是否在寻找类似的东西：

    v = c(1:100)  
f = function(x){return (2*x)}

df <- data.frame(v)

for( i in 1:5) {
   df[,(i+1)] <- f(df[,i])
}
    • 2

  2. 你可以使用Reduce如下方法

    v <- 1:10
k <- 5
f <- \(x) 2 * x
do.call(cbind, Reduce(\(x, y) f(x), rep(list(v), 5), accumulate = TRUE))

    给出结果

          [,1] [,2] [,3] [,4] [,5]
 [1,]    1    2    4    8   16
 [2,]    2    4    8   16   32
 [3,]    3    6   12   24   48
 [4,]    4    8   16   32   64
 [5,]    5   10   20   40   80
 [6,]    6   12   24   48   96
 [7,]    7   14   28   56  112
 [8,]    8   16   32   64  128
 [9,]    9   18   36   72  144
[10,]   10   20   40   80  160
    • 1

  3. 预分配矩阵并填充它的速度大约快 10 倍，尽管较慢的版本仍然只需要大约 0.1 秒即可构建 1000x100 矩阵……使用Reduce()可获得 2 倍速度的额外因子。尝试使用字符串构造方法会遇到“评估嵌套太深”错误。

    f <- function(x) {return (2*x)} 
f1 <- function(n1 = 1000, n2 = 1000) {
    df <- data.frame(seq.int(n1))
    for (i in 1:(n2-1)) {
        df[,(i+1)] <- f(df[,i])
    }
    df <- as.matrix(df)
    dimnames(df) <- NULL
    df
}

f2 <- function(n1= 1000, n2 = 1000) {
    df <- matrix(nrow=n1, ncol = n2)
    df[,1] <- seq.int(n1)
    for (i in 1:(n2-1)) {
        df[,(i+1)] <- f(df[,i])
    }
    df
}

f3 <- function(n1 = 1000, n2 = 1000) { 
    v <- seq.int(n1)
   do.call(cbind, Reduce(\(x, y) f(x), rep(list(v), n2), 
                         accumulate = TRUE)) 
}

    bench:mark(f1(), f2(), f3() )  
expression      min   median `itr/sec` mem_alloc `gc/sec` n_itr  n_gc
  <bch:expr> <bch:tm> <bch:tm>     <dbl> <bch:byt>    <dbl> <int> <dbl>
1 f1()       126.75ms 126.81ms      7.89        NA     3.94     2     1
2 f2()         8.14ms   8.93ms    107.          NA    19.5     33     6
3 f3()         3.67ms   3.98ms    221.          NA    21.2     73     7

    （我认为，如果按行而不是按列增加数据框，则慢速方法会慢得多......）

    • 1

  4. 另一种方法是增加函数公式而不是增加内存对象（参见R-Inferno第 12 页）：

    • 该函数首先生成一个字符串，其中包含对函数 f 的 k 次调用，通过管道运算符链接起来|>，然后解析该字符串并对其进行评估x：
    
    raise_f <- \(f, k, x) {
      parse(text = paste('x |> ',
                         sprintf('(%s)()',  paste(deparse(f), collapse = ' ')) |> 
                rep(k) |> paste(collapse = ' |> ')
      )
      ) |> eval()
    }
    • 在长度为 5 的向量上尝试该函数，将 f 从 1 提升到 3，cbind将结果向量放入矩阵中：
    
    f <- \(x) 2 * x
    k <- 3
    init <- 1:5
    
    do.call(cbind, Map(1:3, f = \(k) raise_f(f, k, 1:5)))

    输出：

    
    ##      [,1] [,2] [,3]
    ## [1,]    2    4    8
    ## [2,]    4    8   16
    ## [3,]    6   12   24
    ## [4,]    8   16   32
    ## [5,]   10   20   40

    与循环矩阵的性能比较：

    
    library(microbenchmark)
    
    microbenchmark(
      loop_a_matrix = for( i in 1:5) {df[,(i+1)] <- f(df[,i])},
      grow_a_formula = do.call(cbind, Map(1:5, f = \(k) raise_f(f, k, 1:100)))
    )
    
    ## Unit: microseconds
    ##            expr    min      lq     mean  median     uq     max neval cld
    ##   loop_a_matrix 5481.6 6350.55 7254.535 7012.95 7999.2 12083.5   100  a 
    ##  grow_a_formula  919.1 1044.00 1335.874 1219.80 1419.6  3817.9   100   b
    • 0

相关问题