Respostas:
Não, não, consulte: Definição da linguagem R: operadores
Seguindo @ GregaKešpret, você pode criar um operador de infix:
`%+=%` = function(e1,e2) eval.parent(substitute(e1 <- e1 + e2))
x = 1
x %+=% 2 ; x
x = %+=% y/2
retorna x = (x + y)/2
. Adicionar parênteses, ou seja, x = %+=% (y/2)
resolve o problema.
R não tem um conceito de increment operator
(como por exemplo ++ em C). No entanto, não é difícil implementar você mesmo, por exemplo:
inc <- function(x)
{
eval.parent(substitute(x <- x + 1))
}
Nesse caso, você chamaria
x <- 10
inc(x)
No entanto, ele introduz despesas gerais de chamada de função, por isso é mais lento do que digitar x <- x + 1
você mesmo. Se não me engano, increment operator
foi introduzido para facilitar o trabalho do compilador, pois ele poderia converter o código diretamente nessas instruções de linguagem de máquina.
INC
As instruções foram introduzidas nos processadores principalmente para a implementação de contadores (consulte o Intel Software Developer's Manual). Eu atualizarei a resposta.
R não possui essas operações porque (a maioria) dos objetos em R são imutáveis. Eles não mudam. Normalmente, quando parece que você está modificando um objeto, na verdade está modificando uma cópia.
Lançamos um pacote, roperators, para ajudar com esse tipo de coisa. Você pode ler mais sobre isso aqui: https://happylittlescripts.blogspot.com/2018/09/make-your-r-code-nicer-with-roperators.html
install.packages('roperators')
require(roperators)
x <- 1:3
x %+=% 1; x
x %-=% 3; x
y <- c('a', 'b', 'c')
y %+=% 'text'; y
y %-=% 'text'; y
# etc
Nós podemos substituir +
. Se unário +
for usado e seu argumento for uma +
chamada unária , aumente a variável relevante no ambiente de chamada.
`+` <- function(e1,e2){
# if unary `+`, keep original behavior
if(missing(e2)) {
s_e1 <- substitute(e1)
# if e1 (the argument of unary +) is itself an unary `+` operation
if(length(s_e1) == 2 &&
identical(s_e1[[1]], quote(`+`)) &&
length(s_e1[[2]]) == 1){
# increment value in parent environment
eval.parent(substitute(e1 <- e1 + 1,list(e1 = s_e1[[2]])))
# else unary `+` should just return it's input
} else e1
# if binary `+`, keep original behavior
} else .Primitive("+")(e1,e2)
}
x <- 10
++x
x
# [1] 11
outras operações não mudam:
x + 2
# [1] 13
x ++ 2
# [1] 13
+x
# [1] 11
x
# [1] 11
Não faça isso, pois você diminuirá tudo. Ou faça-o em outro ambiente e verifique se você não possui grandes loops nessas instruções.
Você também pode fazer isso:
`++` <- function(x) eval.parent(substitute(x <-x +1))
a <- 1
`++`(a)
a
# [1] 2
Existe outra maneira de fazer isso, que eu acho muito fácil, talvez possa ser de alguma ajuda
Eu uso <<-
para essa situação Os operadores <<-
atribuem o valor ao ambiente pai
inc <- function(x)
{
x <<- x + 1
}
e você pode chamar assim
x <- 0
inc(x)
x += 1
oux++
-x = x + 1
funciona.