R: += (plus equals) and ++ (plus plus) equivalent from c++/c#/java, etc.?

Question

Does R have a concept of += (plus equals) or ++ (plus plus) as c++/c#/others do?

No, to do `x += 1` or `x++` - `x = x + 1` works. – Joshua Dawson Mar 29 '17 at 06:12 — Joshua Dawson, Mar 29 '17 at 06:12

score 129 · Accepted Answer · edited Jan 26 '18 at 13:02

129

No, it doesn't, see: R Language Definition: Operators

edited Jan 26 '18 at 13:02

zx8754

46,390
10
104
180

answered Apr 21 '11 at 02:40

Patrick Cuff

27,342
11
65
93

score 66 · Answer 2 · answered Feb 17 '13 at 23:49

66

Following @GregaKešpret you can make an infix operator:

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

answered Feb 17 '13 at 23:49

baptiste

73,538
17
190
281

8

(+1), but a word of warning. Typing `x = %+=% y/2` returns `x = (x + y)/2`. Adding parenthesis, i.e. `x = %+=% (y/2)` solves the problem. – knrumsey Sep 21 '18 at 21:08
@knrumsey Why is that? I would've guessed division would be a higher precedence operator. – David Kelley Feb 17 '19 at 22:16
1

@DavidKelley Not sure. I'm with you there. I ran into this issue working on a project once and it took me an hour to find the issue. – knrumsey Feb 17 '19 at 22:38
Remember you're running a function, not doing an addition. Functions have the highest precedence so without the parenthesis it parses the y as the function input with the division being the next step down the chain. The parenthesis elevate the (y/2) operation to the top of the chain. – Justin Jun 10 '20 at 04:07

score 36 · Answer 3 · answered Apr 21 '11 at 02:51

36

R doesn't have a concept of increment operator (as for example ++ in C). However, it is not difficult to implement one yourself, for example:

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

In that case you would call

x <- 10
inc(x)

However, it introduces function call overhead, so it's slower than typing x <- x + 1 yourself. If I'm not mistaken increment operator was introduced to make job for compiler easier, as it could convert the code to those machine language instructions directly.

answered Apr 21 '11 at 02:51

Grega Kešpret

11,407
6
37
42

3

This function cannot return the value and then increment like a postincrement ++. It's more similar to += or preincrement ++. – Megatron Jul 10 '15 at 18:52
1

Wrong! Incrementation wasn't introduced to make the job of compiler easier. `INC` instruction was introduced **in processors** primarily for implementing counters (cf. Intel Software Developer's Manual). I will update the answer. – banan3'14 Nov 04 '18 at 22:50

score 25 · Answer 4 · answered Apr 21 '11 at 03:14

25

R doesn't have these operations because (most) objects in R are immutable. They do not change. Typically, when it looks like you're modifying an object, you're actually modifying a copy.

answered Apr 21 '11 at 03:14

hadley

98,401
28
176
241

20

While immutability is a great/desirable property for objects (read: less bugs) I don't think immutability relates to the += question. In other languages += can be applied to immutable types (like strings in .net). The operation simply creates a new object and assigns the given variable to that new object. Immutability is maintained and the variable is updated. – Suraj Apr 21 '11 at 13:35
5

Good point. Immutability certainly makes this sort of operation less natural, however. – hadley Apr 22 '11 at 03:20

score 15 · Answer 5 · edited Apr 21 '11 at 07:54

15

Increment and decrement by 10.

require(Hmisc)
inc(x) <- 10 

dec(x) <- 10

edited Apr 21 '11 at 07:54

Gavin Simpson

164,190
25
377
440

answered Apr 21 '11 at 02:34

Wanderer

1,573
4
20
36

9

These functions appear to have been removed from `Hmisc` as of version 4.1.0. – llasram Mar 07 '18 at 15:13
7

@llasram looking at that notation, I cannot blame anyone. – bers Jun 23 '20 at 12:47

score 8 · Answer 6 · answered Sep 24 '18 at 21:44

We released a package, roperators, to help with this kind of thing. You can read more about it here: 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

moodymudskipper · Answer 7 · 2022-02-11T13:02:10.173

7

We can override +. If unary + is used and its argument is itself an unary + call, then increment the relevant object in the calling environment.

`+` <- function(e1,e2){
  # if binary `+`, keep original behavior
  if(!missing(e2)) return(base::`+`(e1, e2))
  
  # if inner call isn't unary `+` called on language object,
  # keep original behavior
  inner_call <- substitute(e1)
  inner_call_is_plus_on_lng <-
    length(inner_call) == 2 &&
    identical(inner_call[[1]], quote(`+`)) &&
    is.language(inner_call[[2]])
  if(!inner_call_is_plus_on_lng) return(base::`+`(e1))
  
  eval.parent(substitute(X <- X + 1, list(X = inner_call[[2]])))
}

x <- 10

++x
x
#> [1] 11

other operations don't change :

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

I can't really recommend it since you're messing with primitives which are optimised for a reason.

edited Feb 11 '22 at 13:02

answered Jan 25 '19 at 14:38

moodymudskipper

42,696
10
102
146

I like this answer. but ++1 ==> " Error in 1 – Masoud Feb 10 '22 at 21:31
Thanks, I reworked the answer, now `++1` returns 1 – moodymudskipper Feb 11 '22 at 13:03
I think ++1 should return 2! – Masoud Feb 11 '22 at 18:50
I don't think so, `++` is incrementing an object in place, it works only on symbols, `1` isn't a symbol, I can't change the value of `1`, so what happens is that I fall back to the default behavior of `+`. – moodymudskipper Feb 12 '22 at 12:00

score 1 · Answer 8 · answered Oct 25 '20 at 22:31

1

We can also use inplace

library(inplace)
x <- 1
x %+<-% 2

answered Oct 25 '20 at 22:31

akrun

789,025
32
460
575

score -1 · Answer 9 · answered Mar 16 '21 at 07:31

If you want to use i++ in an array to increment the index, you can try i <- i + 1, for example,

k = 0
a = 1:4
for (i in 1:4) 
    cat(a[k <- k + 1], " ")
# 1 2 3 4

but here <- can NOT be replaced with =, which does not update the index,

k = 0
a = 1:4
for (i in 1:4) 
    cat(a[k = k + 1], " ")
# 1 1 1 1

since = and <- are not always equivalent, as said in ?`<-`

R: += (plus equals) and ++ (plus plus) equivalent from c++/c#/java, etc.?

9 Answers9

Linked

Related