Início / coding / Perguntas / 79334110
Accepted
Pete
Asked: 2025-01-07 03:23:02 +0800 CST

Crie uma nova variável multiplicando as variáveis ​​correspondentes e somando

  • 772

Tenho uma longa lista de variáveis ​​que desejo multiplicar pelas variáveis ​​correspondentes e somar. a_1corresponde a b_1, a_2a b_2etc. A saída desejada seria calculada por(a_1*b_1 + a_2*b_2...)

library(dplyr)
(df <- tibble(
  a_1 = sample(1:5),
  a_2 = sample(1:5),
  b_1 = sample(1:5),
  b_2 = sample(1:5),
  desired_output = (a_1*b_1 + a_2*b_2)
))

# A tibble: 5 × 5
    a_1   a_2   b_1   b_2 desired_output
  <int> <int> <int> <int>          <int>
1     4     5     1     3             19
2     1     2     2     5             12
3     2     1     4     2             10
4     5     3     5     1             28
5     3     4     3     4             25

Eu tentei e falhei em escrever uma função para fazer isso (sou muito novo em tentar escrever funções!) por exemplo

df %>%
  mutate(desired_output = function(df) {
  for (i in 1:2) {
    y1 <- get(paste0(x,'$','a_',i))
    y2 <- get(paste0(x,'$','a_',i))
    z <- y1*y2 
  }
  return(z)
}

5 respostas

  1. Das soluções aqui, eu provavelmente usaria (1), (2b) ou (5), dependendo de quais pacotes você prefere usar (dplyr, base, dplyr/dplyover, respectivamente).

    1) escolha várias pick(...)chamadas e use rowSumscomo mostrado:

    df %>%
 mutate(desired_output = rowSums(pick(starts_with("a")) * pick(starts_with("b"))))

    dando

    # A tibble: 5 × 5
    a_1   a_2   b_1   b_2 desired_output
  <int> <int> <int> <int>          <dbl>
1     4     5     1     3             19
2     1     2     2     5             12
3     2     1     4     2             10
4     5     3     5     1             28
5     3     4     3     4             25

    2) transformar Uma tradução razoavelmente direta disso para a base R resulta em:

    transform(df, desired_output = rowSums(
  df[startsWith(names(df), "a")] * df[startsWith(names(df), "b")]
))

    2a) Esta versão de (2) é ainda mais compacta, embora (2) pareça mais clara:

    transform(df, desired_output = rowSums(df[1:2] * df[-(1:2)]))

    2b) (2) não é amigável ao pipe base, pois usa dfvários tempos. Se usado dentro de um pipe, faça assim (ou use uma função anônima, embora isso tenda a ser difícil de ler devido a todos os parênteses na sintaxe, razão pela qual preferimos o código aqui):

    df |>
  list(x = _) |>
  with(transform(x, desired_output = rowSums(
    x[startsWith(names(x), "a")] * x[startsWith(names(x), "b")]
  )))

    3) mutate/get Uma abordagem razoavelmente próxima da tentativa na questão é

    df %>%
 mutate(desired_output = {
   tmp <- 0
   for(i in 1:2) tmp <- tmp + get(paste0("a_", i)) * get(paste0("b_", i))
   tmp
 })

    4) transformar/obter ou traduzir (3) para a base R:

    transform(df, desired_output = {
  tmp <- 0
  for(i in 1:2) tmp <- tmp + get(paste0("a_", i)) * get(paste0("b_", i))
  tmp
})

    5) dplyover O pacote dplyover no github tem um across2que é semelhante across, mas manipula dois conjuntos de colunas ao mesmo tempo.

    # remotes::install_github("TimTeaFan/dplyover")
library(dplyr)
library(dplyover)

df %>%
  mutate(desired_output = rowSums(
    across2(starts_with("a"), starts_with("b"), `*`)
  ))

    6) reduce2 reduce2 no pacote purrr pode manipular dois conjuntos de colunas de uma vez, embora comparado ao across2seu uso seja um pouco mais complicado. Em troca, envolve apenas pacotes do CRAN.

    library(dplyr)
library(purrr)

df %>%
  mutate(desied_output = reduce2(
    pick(starts_with("a")),
    pick(starts_with("b")),
    \(z, x, y) z + x*y,
    .init = 0
  ))

    Observação

    Devido ao uso de números aleatórios na questão, a entrada não é reproduzível. Da próxima vez, use set.seed(...)primeiro.

    Estes são os dados que foram usados ​​na questão mostrados de forma reproduzível:

    library(tibble)

df <- tibble(
  a_1 = c(4L, 1L, 2L, 5L, 3L),
  a_2 = c(5L, 2L, 1L, 3L, 4L),
  b_1 = c(1L, 2L, 4L, 5L, 3L),
  b_2 = c(3L, 5L, 2L, 1L, 4L)
)
    • 4

  2. No R básico, para uma solução geral, você pode primeiro identificar as colunas que deseja pelo padrão (aqui, as colunas de interesse ( ccols) são identificadas por uma letra, sublinhado e número - por exemplo, "\\D_\\d") e, em seguida, usar sapplywithin rowSumspara realizar a multiplicação e a adição:

    ccols <- unique(gsub("\\d", "", 
                     grep("\\D_\\d", names(df), value = TRUE)))

df$desired <- rowSums(
  sapply(seq_along(ccols), \(x) {
    df[[paste0(ccols[1], x)]] * df[[paste0(ccols[2], x)]]
  }))

    a_1   a_2   b_1   b_2 desired
  <int> <int> <int> <int>   <dbl>
1     3     5     5     1      20
2     3     4     3     1      13
3     2     1     3     5      11
4     2     2     1     3       8
5     3     3     4     2      18

    Note que se você tivesse certeza de que eram simplesmente "a_xx" e "b_xx", você poderia simplesmente fazer:

    df$desired <- rowSums(
  sapply(1:2, \(x) {
    df[[paste0("a_", x)]] * df[[paste0("b_", x)]]
  }))

    Dados (com semente)

    set.seed(123)
df <- tibble::tibble(
  a_1 = sample(1:5, 5, replace = TRUE),
  a_2 = sample(1:5, 5, replace = TRUE),
  b_1 = sample(1:5, 5, replace = TRUE),
  b_2 = sample(1:5, 5, replace = TRUE)
)
    • 3

  3. Aqui está uma opção base R com split.default+rowSums

    transform(
  df,
  prodsum = with(
    split.default(df, sub("_.*", "", names(df))),
    rowSums(a * b)
  )
)

    o que dá

      a_1 a_2 b_1 b_2 prodsum
1   1   5   3   2      13
2   4   3   5   5      35
3   3   4   1   4      19
4   5   2   4   3      26
5   2   1   2   1       5

    Dados

    set.seed(0)
(df <- tibble(
  a_1 = sample(1:5),
  a_2 = sample(1:5),
  b_1 = sample(1:5),
  b_2 = sample(1:5)
))
    • 3
  4. Best Answer

    Uma opção poderia ser:

    df %>%
 mutate(desired_output = rowSums(across(starts_with("a"), 
                                        ~ . * get(stringr::str_replace(cur_column(), "a_", "b_")))))

    a_1   a_2   b_1   b_2 desired_output
  <int> <int> <int> <int>          <dbl>
1     2     3     2     5             19
2     4     2     1     3             10
3     3     4     5     4             31
4     5     1     4     2             22
5     1     5     3     1              8
    • 2

  5. Acho muito mais intuitivo nessas situações colocar os dados em formato longo. Como você marcou isso significa: tidyr::pivot_longer(), um rápido mutate()para criar o resultado, então pivot_wider().:

    df |>
    mutate(rn = row_number()) |>
    tidyr::pivot_longer(
        cols = -rn,
        names_to = c(".value", "group"),
        names_sep = "_"
    ) |>
    mutate(result = sum(a * b), .by = rn) |>
    tidyr::pivot_wider(
        id_cols = c(rn, result),
        names_from = group,
        values_from = c(a, b),
        names_glue = "{.value}_{group}"
    ) |>
    select(c(names(df)), desired_output = result)

# # A tibble: 5 × 5
#     a_1   a_2   b_1   b_2 desired_output
#   <int> <int> <int> <int>          <int>
# 1     4     5     1     3             19
# 2     1     2     2     5             12
# 3     2     1     4     2             10
# 4     5     3     5     1             28
# 5     3     4     3     4             25

    É verdade que isso envolve mais linhas de código do que outras abordagens, mas a) o cálculo em si result = sum(a * b)é muito mais fácil de entender nesse formato (para mim, pelo menos) e b) geralmente faz mais sentido pular pivot_wider()e manter os dados em formato longo para as próximas etapas da manipulação de dados, caso em que isso se torna muito mais curto.

    • 2

relate perguntas