Início / coding / Perguntas / 79339550
Accepted
oibaFox
Asked: 2025-01-08 22:30:53 +0800 CST

Comportamento inesperado de "formula" com "data.table" em R

  • 772

Estou tentando formar dinamicamente uma fórmula para usar em dynlm. Encontro um comportamento functionque não entendo, que pode ser visto neste código:

library(data.table)
dt_test <- data.table("a"=rnorm(10), "b"=1:5)

dt_test[, .(.(
   formula("z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + tt + tt2")
 )), .(b)]

Espera-se que o código acima produza fórmulas (idênticas) para cada valor de b. Esta fórmula é incluída .(.(...))para retornar uma lista, apenas para que ela possa ser armazenada corretamente em uma coluna do data.table original.

Entretanto, a fórmula retornada não corresponde à string fornecida originalmente, mas adiciona uma vírgula entre +e tt, como você pode ver na saída:

       b                                                                           V1
   <int>                                                                       <list>
1:     1 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
2:     2 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
3:     3 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
4:     4 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
5:     5 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2

Basicamente, ele adiciona uma vírgula onde não há nenhuma. Ele faz isso até mesmo reorganizando os termos da soma, mas para de fazer isso se eu apagar q_val, por exemplo. O mesmo vale para as.formula.

Gostaria de entender o que está acontecendo e evitar isso.

2 respostas

  1. Best Answer

    Este é apenas um problema de impressão cosmética devido à maneira como R trata fórmulas longas:

    Se você executar:

    formula(paste0("z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + tt + tt2"))

    Você verá que o R imprimirá em 2 linhas por padrão, cortando em "tt + tt2" (não importa quão largo seja o console):

    #z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + 
#    tt + tt2

    Isso é um tanto significativo para a maneira como R mostra a fórmula cosmeticamente - se você executar deparse, ele produzirá um vetor de caracteres de comprimento 2:

    deparse(formula(paste0("z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + tt + tt2")))

# [1] "z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + "
# [2] "    tt + tt2"

    Entretanto, ao atribuir seu código original como df_formulas, você verá que ele armazena a fórmula normalmente:

    df_formulas <- dt_test[, .(.(
  formula("z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + tt + tt2")
)), .(b)]

dt_formulas[[2]]

# [[1]]
# z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 +
#   tt + tt2
# <environment: 0x7fa96ff6ffd8>
#   
# [[2]]
# z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 +
#   tt + tt2
# <environment: 0x7fa96ff6ffd8>
# ....

    Como você mencionou, é por isso também que você não vê a vírgula se remover algumas das variáveis ​​no código da fórmula. Não tem nada a ver com o que você está removendo especificamente, você está simplesmente reduzindo o comprimento o suficiente para evitar a quebra de linha automática.

    • 5

  2. Talvez você queira adicionar uma listcoluna, algo assim:

    > library(data.table)
> dt_test <- data.table("a"=rnorm(10), "b"=1:5)
> dt_test[, x := list(rep(list(as.formula("z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + tt + tt2")), .N))]
> dt_test$x[[1]]
z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + 
    tt + tt2
<environment: 0x56169e0ce3c8>

    Isso parece estranho durante a impressão,

    > dt_test |> head(2)
            a     b                                                                            x
        <num> <int>                                                                       <list>
1: -0.5439367     1 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2
2:  0.1078461     2 z_val ~ s_val + q_val + L(s_dval, 32:0) + L(q_dval, 2:0) + 1 + ,    tt + tt2

    mas na verdade é uma fórmula:

    > class(dt_test$x[[1]])
[1] "formula"

    Você pode adaptar isso para suas .(b)coisas dinâmicas. Não tenho certeza se você precisa repdisso; data.tablenão gosta de reciclagem, então é necessário neste exemplo.

    • 3

relate perguntas