R: += (plus égale à) et ++ (plus en plus) équivalent à partir de c++/c#/java, etc.?

Ne R ont un concept de += (plus égale à) ou ++ (plus en plus) comme c++/c#/autres?

Non, x += 1 ou x++ - x = x + 1 œuvres.

OriginalL'auteur SFun28 | 2011-04-21

  1. 89

    Non, ce n'est pas le cas, voir: R De Définition De Langage: Les Opérateurs

    Et, c'vais jeter un peu drôle erreurs, si vous les utilisez...

    OriginalL'auteur Patrick Cuff

  2. 54

    Suivant @GregaKešpret vous pouvez faire un opérateur infixe:

    `%+=%` = function(e1,e2) eval.parent(substitute(e1 <- e1 + e2))
x = 1
x %+=% 2 ; x
    (+1), mais un mot d'avertissement. En tapant x = %+=% y/2 retourne x = (x + y)/2. L'ajout de parenthèses, c'est à dire x = %+=% (y/2) résout le problème.
    Pourquoi est-ce? Je l'ai deviné la division serait une priorité plus élevée de l'opérateur.
    Pas sûr. Je suis avec vous. J'ai rencontré ce problème en travaillant sur un projet à la fois et il m'a fallu une heure pour trouver le problème.

    OriginalL'auteur baptiste

  3. 30

    R ne dispose pas d'un concept de increment operator (comme par exemple en C++). Cependant, il n'est pas difficile à mettre en œuvre un vous-même, par exemple:

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

    Dans ce cas, vous devrez appeler

    x <- 10
inc(x)

    Cependant, elle introduit un appel de fonction, les frais généraux, il est donc plus lent que de taper x <- x + 1 vous-même. Si je ne me trompe pas increment operator a été introduit à faire de l'emploi pour le compilateur plus facile, car il pourrait convertir le code à ces instructions en langage machine directement.

    Cette fonction ne peut pas retourner de la valeur et puis incrémenter comme une post-incrémentation ++. Il est de plus en plus semblables à += ou pré-incrémentation ++.
    Faux! L'incrémentation n'était pas introduit de faire le travail de compilateur plus facile. INC instruction a été introduite dans les processeurs principalement pour la mise en œuvre des compteurs (cf. Intel Software developer's Manual). Je vais mettre à jour la réponse.

    OriginalL'auteur Grega Kešpret

  4. 14

    D'incrémentation et de décrémentation par 10.

    require(Hmisc)
inc(x) <- 10 

dec(x) <- 10
    Ces fonctions semblent avoir été retiré de Hmisc de la version 4.1.0.

    OriginalL'auteur Wanderer

  5. 13

    R n'a pas ces opérations, car la plupart des objets dans R sont immuables. Ils ne changent pas. Généralement, quand il semble que vous êtes en train de modifier un objet, vous êtes en fait de la modification d'une copie.

    Alors que l'immuabilité est un grand/propriété souhaitable pour les objets (lire: moins de bugs) je ne pense pas que l'immuabilité se rapporte à l' += question. Dans d'autres langues += peut être appliquée à d'immuables types (comme les chaînes .net). L'opération simplement crée un nouvel objet et l'affecte à la variable donnée à ce nouvel objet. L'immuabilité est maintenue et que la variable est mise à jour.
    Bon point. L'immutabilité certainement fait ce genre d'opération moins naturel, cependant.

    OriginalL'auteur hadley

  6. 3

    Nous avons sorti un paquet, roperators, à l'aide de ce genre de chose. Vous pouvez en lire 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

    OriginalL'auteur Benbob

  7. 1

    Juste pour le fun :

    `+` <- function(e1,e2){
    if(missing(e2)) {
      s_e1 <- substitute(e1)
      if(length(s_e1) == 2 &&
         identical(s_e1[[1]], quote(`+`)) && 
         length(s_e1[[2]]) == 1){
        eval.parent(substitute(e1 <- e1 + 1,list(e1 = s_e1[[2]])))
      } else e1
    } else .Primitive("+")(e1,e2)
}

x <- 10
++x
x
# [1] 11

    autres opérations ne changent pas :

    x + 2
# [1] 13
x ++ 2
# [1] 13
+x
# [1] 11
x
# [1] 11
    Grande réponse à une vieille question.

    OriginalL'auteur Moody_Mudskipper