Início / coding / Perguntas / 78044522
Accepted
Joseff Kolman
Asked: 2024-02-23 07:32:06 +0800 CST

Como criar uma nova coluna que soma cumulativamente a soma cumulativa da coluna existente?

  • 772

Usando funções tidyverse, pretendo criar uma nova coluna de dados que some a soma cumulativa na primeira coluna, mas use incrementos não maiores que incr.

Isso poderia começar com df

incr <- 1.5
df <- data.frame(a = c(6,0,0,2.5,0,0))
df
    a
1 6.0
2 0.0
3 0.0
4 2.5
5 0.0
6 0.0

em seguida, crie uma nova coluna busando incr:

    a   b
1 6.0 1.5
2 0.0 1.5
3 0.0 1.5
4 2.5 1.5
5 0.0 1.5
6 0.0 1.0

Encontrei tidyr::uncount()e parecia uma função que poderia funcionar, mas preciso usar incrementos não inteiros. Geralmente tento transformar e usar funções vetorizadas e pensei um pouco para executá-las rowwise(), mas a maioria das minhas ideias requer iteração.

Do comentário abaixo: Se as analogias forem úteis, pense nisso como downloads em fila. A coluna amostra que você pressiona para baixar 6 MB no tempo 1, 0 MB para os tempos 2 e 3, depois pressiona para baixar 2,5 MB no tempo 4. Sua conexão, no entanto, só pode baixar na velocidade de incr. Então, se incrfor 1,5, a coluna bmostra o que realmente foi baixado. Você usa totalmente essa velocidade de conexão a cada período até baixar o resíduo final ( 1.0) no tempo 6.

Para destacar melhor a dimensionalidade, aqui está outro df:

incr <- 1.5
df <- data.frame(a = rep(0,100),b=rep(0,100))
df$a[c(30,33,38)] = c(6,2.5,1)
df[30:39,]
     a b
30 6.0 0
31 0.0 0
32 0.0 0
33 2.5 0
34 0.0 0
35 0.0 0
36 0.0 0
37 0.0 0
38 1.0 0
39 0.0 0

com uma saída desejada

     a   b
30 6.0 1.5
31 0.0 1.5
32 0.0 1.5
33 2.5 1.5
34 0.0 1.5
35 0.0 1.0
36 0.0 0.0
37 0.0 0.0
38 1.0 1.0
39 0.0 0.0

4 respostas

  1. Best Answer

    porque não sei quando desistir, acho que a única solução é a iteração. Mas acho que você sempre pode fazer iterações em C++ para torná-lo tão rápido quanto uma função vetorizada:

    Rcpp::cppFunction(
  "
    NumericVector iterate_to_cumsum(NumericVector v1, double incr) {
    int x = v1.size();
    NumericVector v2(x);

    for (int i =0; i < x; ++i) {
      v2[i] = std::max(0.0, std::min(incr, sum(v1[Rcpp::Range(0, i)]) - sum(v2)));
    }

    return v2;

  }
"
)

library(tidyverse)

df <- data.frame(a = c(6, 0, 0, 2.5, 0, 0, 0, 0, 1, 0, 3, 0, 0, 0))
incr <- 1.5

df |> 
  mutate(b = iterate_to_cumsum(a, incr))
#>      a   b
#> 1  6.0 1.5
#> 2  0.0 1.5
#> 3  0.0 1.5
#> 4  2.5 1.5
#> 5  0.0 1.5
#> 6  0.0 1.0
#> 7  0.0 0.0
#> 8  0.0 0.0
#> 9  1.0 1.0
#> 10 0.0 0.0
#> 11 3.0 1.5
#> 12 0.0 1.5
#> 13 0.0 0.0
#> 14 0.0 0.0
    • 2

  2. Uma possibilidade é usar uma fábrica de funções. Isso permite salvar algumas informações de estado, neste caso um restante, o que é útil para o seu cálculo. A iteração vem de dentro map_dbl, mas esta não é uma resposta vetorizada:

    library(purrr)
library(dplyr)

incr_cap <- function(incr) {
  force(incr)
  remainder <- NULL
  function(curv) {
    val <- if (is.null(remainder)) curv else curv + remainder
    if (val > incr) {
      remainder <<- val - incr
      return(incr)
    } else if (val > 0) {
      remainder <<- 0 
      return(val)
    } else {
      remainder <<- 0
      return(0)
    }
  }
}

df |>
  mutate(b = map_dbl(a, incr_cap(1.5)))
#      a   b
# 30 6.0 1.5
# 31 0.0 1.5
# 32 0.0 1.5
# 33 2.5 1.5
# 34 0.0 1.5
# 35 0.0 1.0
# 36 0.0 0.0
# 37 0.0 0.0
# 38 1.0 1.0
# 39 0.0 0.0
    • 1

  3. Farei isso com um forloop com várias ifinstruções:

    Configurar dataframe

    incr <- 1.5
df <- data.frame(a = rep(0,100),b=rep(0,100))
df$a[c(30,33,38)] = c(6,2.5,1)
df <- df[29:39,]
df
     a b
29 0.0 0 # note I included first row as 0 to test
30 6.0 0
31 0.0 0
32 0.0 0
33 2.5 0
34 0.0 0
35 0.0 0
36 0.0 0
37 0.0 0
38 1.0 0
39 0.0 0

    Forloop e ifinstruções:

    for (i in 1:nrow(df)) {
  if (i == 1 & df$a[[1]] < incr) {
    df$b[i] <- df$a[[1]]
  } else if (sum(df$a[1:i]) - sum(df$b[1:i]) > incr) {
    df$b[i] <- incr
  } else {
    df$b[i] <- sum(df$a[1:i]) - sum(df$b[1:i]) 
  } 
}

    Saída

    df
     a   b
29 0.0 0.0
30 6.0 1.5
31 0.0 1.5
32 0.0 1.5
33 2.5 1.5
34 0.0 1.5
35 0.0 1.0
36 0.0 0.0
37 0.0 0.0
38 1.0 1.0
39 0.0 0.0
    • 1

  4. Em termos de implementação, usei a função Rcpp do @Andy Baxter e funcionou muito bem!

    Para futuros usuários que desejam resolver isso apenas com o tidyverse e sem C++: Concordando com a conclusão de @Andy Baxter de que isso exigiria iteração, desenvolvi um método viável, embora desajeitado, começando case_when()com a linha 100 dfacima:

    df2 <- df %>% mutate(a_sum = cumsum(a)) %>%
   rowwise() %>%
   mutate(
     b_sum = lag(b,1,default = 0) + b,
     b=case_when(
     lag(a_sum,1,default = 0) == 0 & a_sum != 0 ~ incr,
     lag(b_sum,1,default = 0) == 0 ~ 0,
     lag(b_sum,1,default = 0) < lag(a_sum,1) ~ min(incr,lag(a_sum,1)-lag(b_sum,1)),
     .default = 0
     )) %>% select(a,b_sum)
colnames(df2) <- c("a","b")

df2[30:39,]
# A tibble: 10 × 2
# Rowwise: 
       a     b
   <dbl> <dbl>
 1   6     1.5
 2   0     1.5
 3   0     1.5
 4   2.5   1.5
 5   0     1.5
 6   0     1  
 7   0     0  
 8   0     0  
 9   1     1  
10   0     0
    • 1

relate perguntas