Início / coding / Perguntas / 77671811
Accepted
Stéphane Laurent
Asked: 2023-12-17 01:21:12 +0800 CST

Conversão de uma árvore de sintaxe abstrata com R

  • 772

Dada uma expressão aritmétrica, por exemplo x + y*z, quero convertê-la para add(x, multiply(y, z)).

Encontrei uma função útil aqui :

> getAST <- function(ee) purrr::map_if(as.list(ee), is.call, getAST)
> getAST(quote(x + y*z)) 
[[1]]
`+`

[[2]]
x

[[3]]
[[3]][[1]]
`*`

[[3]][[2]]
y

[[3]][[3]]
z

Pode-se usar rapply(result, as.character, how = "list")para obter caracteres em vez de símbolos.

Como obter add(x, multiply(y, z))deste AST (o resultado)? Isso se torna mais complicado quando há alguns parênteses:

> getAST(quote((x + y) * z)) 
[[1]]
`*`

[[2]]
[[2]][[1]]
`(`

[[2]][[2]]
[[2]][[2]][[1]]
`+`

[[2]][[2]][[2]]
x

[[2]][[2]][[3]]
y



[[3]]
z

Não exijo a resposta, devo usar a getASTfunção. É apenas um caminho possível a seguir.

É claro que no meu caso de uso real as expressões são mais longas.

Aqui está uma solução (eu acho) para o caso em que não há parênteses:

getAST <- function(ee) purrr::map_if(as.list(ee), is.call, getAST)

ast <- rapply(getAST(quote(x + y*z)), as.character, how = "list")

convertAST <- function(ast) {
  op <- switch(
    ast[[1]],
    "+" = "add",
    "-" = "subtract",
    "*" = "multiply",
    "/" = "divide"
  )
  left <- ast[[2]]
  right <- ast[[3]]
  if(is.character(left) && is.character(right)) {
    return(sprintf("%s(%s, %s)", op, left, right))
  }
  if(is.character(left)) {
    return(sprintf("%s(%s, %s)", op, left, convertAST(right)))
  }
  if(is.character(right)) {
    return(sprintf("%s(%s, %s)", op, convertAST(left), right))
  }
  return(sprintf("%s(%s, %s)", op, convertAST(left), convertAST(right)))
}

convertAST(ast)

2 respostas

  1. Best Answer

    Podemos usar substituto assim:

    subst <- function(e, sub = list(`+` = "add", 
                                `-` = "minus",
                                `/` = "divide",
                                `*` = "multiply")) {
  sub <- Map(as.name, sub)
  do.call("substitute", list(e, sub))
}

# test
e <- quote(x + (y + 1) * z)
res <- subst(e); res
## add(x, multiply((add(y, 1)), z))

# evaluate test against values
add <- `+`; multiply <- `*`; x <- 1; y <- 2; z <- 3
eval(res)
## [1] 10

    Se você quiser um resultado de sequência de caracteres, então

    deparse1(subst(e))
## [1] "add(x, multiply((add(y, 1)), z))"
    • 3

  2. Pode ser apenas porque eu não entendo rapplymuito bem, mas sempre que tento usá-lo meu código fica mais complexo do que apenas escrever minha própria função recursiva.

    Neste caso coloquei a função recursiva em um wrapper fino que permite a entrada direta de expressões sem usar quote(se desejar)

    sub_call <- function(input, direct = TRUE,
                     subs = list(`+` = "add", `-` = "minus", 
                                 `/` = "divide", `*` = "multiply")) {
  scall <- function(x, subs) {
    if(is.call(x))
    {
      if(as.character(x[[1]]) %in% names(subs)) {
        x[[1]] <- str2lang(subs[[match(as.character(x[[1]]), names(subs))]])
      }
    }
    if(length(x) == 1) return(x) 
    x[-1] <- lapply(x[-1], scall, subs = subs)
    x
  }

  if(direct) return(scall(as.list(match.call())$input, subs))
  return(scall(input, subs))
}

    Isso permite a entrada direta de uma expressão:

    sub_call(x + y*z)
#> add(x, multiply(y, z))

    Ou entrada indireta:

    my_expr <- quote(x + y*z)

sub_call(my_expr, direct = FALSE)
#> add(x, multiply(y, z))

    E lida com aninhamentos arbitrariamente profundos, deixando os parênteses intactos:

    sub_call(sin(((x + (1/3))^2)))
#> sin(((add(x, (divide(1, 3))))^2))
    • 1

relate perguntas