R: += (plus equals) and ++ (plus plus) equivalent from c++/c#/java, etc.?
ROperatorsVariable AssignmentIncrementR Problem Overview
Does R have a concept of +=
(plus equals) or ++
(plus plus) as c++/c#/others do?
R Solutions
Solution 1 - R
No, it doesn't, see: R Language Definition: Operators
Solution 2 - R
Following @GregaKešpret you can make an infix operator:
`%+=%` = function(e1,e2) eval.parent(substitute(e1 <- e1 + e2))
x = 1
x %+=% 2 ; x
Solution 3 - R
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.
Solution 4 - R
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.
Solution 5 - R
Increment and decrement by 10.
require(Hmisc)
inc(x) <- 10
dec(x) <- 10
Solution 6 - R
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
Solution 7 - R
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.
Solution 8 - R
We can also use inplace
library(inplace)
x <- 1
x %+<-% 2
Solution 9 - R
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 ?`<-`