web-dev-qa-db-fra.com

R: + = (plus égal) et ++ (plus plus) équivalent de c ++ / c # / Java, etc.?

Est-ce que R a un concept de += (plus égal) ou ++ (plus plus) comme le font c ++/c #/les autres?

roperatorsvariable-assignmentincrement
133
SFun28

Non, voir: Définition du langage R: opérateurs

99
Patrick Cuff

Après @ GregaKešpret, vous pouvez créer un opérateur infixe:

`%+=%` = function(e1,e2) eval.parent(substitute(e1 <- e1 + e2))
x = 1
x %+=% 2 ; x
59
baptiste

R n'a pas le concept de increment operator _ (comme par exemple ++ en C). Cependant, il n’est pas difficile d’en implémenter vous-même, par exemple:

inc <- function(x)
{
 eval.parent(substitute(x <- x + 1))
}

Dans ce cas, vous appelez

x <- 10
inc(x)

Cependant, il introduit une surcharge d’appel de fonction, il est donc plus lent que taper x <- x + 1 toi même. Si je ne me trompe pas increment operator a été introduit pour faciliter la tâche du compilateur, car il pouvait convertir directement le code en instructions de langage machine.

31
Grega Kešpret

R n'a pas ces opérations car (la plupart) les objets de R sont immuables. Ils ne changent pas. En règle générale, lorsque vous modifiez un objet, vous modifiez en fait une copie.

17
hadley

Incrémenter et décrémenter de 10.

require(Hmisc)
inc(x) <- 10 

dec(x) <- 10
15
Wanderer

Nous avons publié un paquet, opérateurs, pour aider avec ce genre de chose. Vous pouvez en savoir plus à ce sujet ici: 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
3
Benbob

Nous pouvons remplacer +. Si unaire + est utilisé et son argument est lui-même un unaire + appel, puis incrémentez la variable appropriée dans l’environnement appelant.

`+` <- 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

les autres opérations ne changent pas:

x + 2
# [1] 13
x ++ 2
# [1] 13
+x
# [1] 11
x
# [1] 11

Ne le faites pas car vous allez tout ralentir. Ou faites-le dans un autre environnement et assurez-vous de ne pas avoir de grandes boucles sur ces instructions.

Vous pouvez aussi simplement faire ceci:

`++` <- function(x) eval.parent(substitute(x <-x +1))
a <- 1
`++`(a)
a
# [1] 2
3
Moody_Mudskipper