Início / coding / Perguntas / 78876734
Accepted
Mohan
Asked: 2024-08-16 04:25:17 +0800 CST

Dado um vetor v e fn f, como faço para gerar a matriz {v, f(v), f(f(v)), ... f^k(v)}?

  • 772

Eu tenho um vetor xe uma função f. Preciso gerar a matriz cuja primeira coluna é v, segunda coluna é f(v), e assim por diante até a coluna final f^k(v). Em uma linguagem funcional eu poderia usar uma operação de desdobramento . Dei uma olhada no purrrcheatsheet, mas não consigo encontrar nenhum análogo.

Se você precisar de um exemplo concreto, pegue v = c(1:100)e f = function(x){return (2*x)}- mas por favor não explore o fato de que f^k tem uma bela forma fechada neste caso.

4 respostas

  1. Best Answer

    Você está procurando algo como:

    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. Você poderia usar Reducecomo abaixo

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

    que dá resultado

          [,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. Pré-alocar uma matriz e preenchê-la é cerca de 10x mais rápido, embora a versão mais lenta ainda leve apenas cerca de 0,1 segundos para construir uma matriz 1000x100... usando Reduce()ganha fator adicional de 2x velocidade. Tentar usar o método de construção de string gera um erro de "avaliação aninhada muito profundamente".

    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

    (Acho que o método lento seria muito mais lento se você aumentasse o quadro de dados em linhas, em vez de em colunas ...)

    • 1

  4. Outra abordagem, aumentando a fórmula da função em vez do objeto de memória (ver R-Inferno p. 12):

    • esta função primeiro gera uma string, contendo k chamadas para a função f, encadeada com o operador pipe |>, depois analisa a string e a avalia em x:
    
    raise_f <- \(f, k, x) {
      parse(text = paste('x |> ',
                         sprintf('(%s)()',  paste(deparse(f), collapse = ' ')) |> 
                rep(k) |> paste(collapse = ' |> ')
      )
      ) |> eval()
    }
    • tente a função em um vetor de comprimento 5, aumente f de 1 para 3, cbindresultando vetores na matriz:
    
    f <- \(x) 2 * x
    k <- 3
    init <- 1:5
    
    do.call(cbind, Map(1:3, f = \(k) raise_f(f, k, 1:5)))

    saída:

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

    Comparação de desempenho com loop de uma matriz:

    
    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

relate perguntas