R Operators: Arithmetic, Comparison, Logical, %in% and %%

The Operators R Gives You

R's operators fall into four working groups: arithmetic (+ - * / ^ %% %/%), comparison (== != < <= > >=), logical (& | && || ! xor), and the membership test %in%. Two things make them different from most languages: nearly all of them are vectorized - they operate on whole vectors at once, element by element - and R has two AND operators and two OR operators that are not interchangeable. This page covers all of them, plus the precedence traps that produce silently wrong answers.

Arithmetic: +, -, *, /, ^, %% and %/%

The first five do what you expect. The two percent-wrapped ones - %% (modulo, the remainder) and %/% (integer division, the quotient) - are the ones people search for:

a <- 17
b <- 5

print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4
print(a ^ b)    # 1419857
print(a %% b)   # 2  - the remainder of 17 / 5
print(a %/% b)  # 3  - how many whole times 5 fits into 17

Note that / always does floating-point division - 17 / 5 is 3.4, never 3. If you want the whole-number part, that's exactly what %/% is for.

The everyday job of %% is divisibility. A number is even when dividing by 2 leaves no remainder:

n <- 42
print(n %% 2 == 0)   # TRUE - even

print(-7 %% 3)       # 2, not -1

That second line is worth a pause: with a negative operand, R's %% returns a result with the sign of the divisor (-7 %% 3 is 2, because -7 = -3 * 3 + 2). Some languages do it the other way; if you're porting code, check.

Comparison Operators Are Vectorized

==, !=, <, <=, >, >= compare element by element and return a logical vector, not a single answer:

scores <- c(45, 72, 88, 60)

print(scores >= 60)           # FALSE TRUE TRUE TRUE
print(scores[scores >= 60])   # 72 88 60

This is the engine behind almost all filtering in R - you compare a whole vector against a value, get a logical mask, and use the mask to subset. One caution with == on decimals: floating-point numbers are stored approximately, so 0.1 + 0.2 == 0.3 is FALSE. For decimal comparisons, prefer all.equal() or check abs(x - y) < 1e-9.

Logical Operators: & vs && (the Classic Confusion)

R has two AND operators and two OR operators, and picking the wrong one is a rite of passage.

& and | are vectorized. They combine two logical vectors element by element:

sunny <- c(TRUE, TRUE, FALSE, FALSE)
warm  <- c(TRUE, FALSE, TRUE, FALSE)

print(sunny & warm)   # TRUE FALSE FALSE FALSE
print(sunny | warm)   # TRUE TRUE TRUE FALSE
print(!sunny)         # FALSE FALSE TRUE TRUE

Use these whenever you're building a filter over data: df[df$age > 30 & df$city == "Lisbon", ].

&& and || are scalar and short-circuit. They take single values, return a single TRUE/FALSE, and skip the second operand entirely if the first one already settles the answer:

x <- 8

print(x > 0 && x %% 2 == 0)         # TRUE - both checked
print(x < 0 && stop("never runs"))  # FALSE - stop() is never evaluated

That second line demonstrates short-circuiting: because x < 0 is FALSE, R never evaluates the stop() call. This is exactly why && belongs in if() conditions - you can write if (!is.na(x) && x > 10) and the x > 10 part is safely skipped when x is NA.

The rule of thumb: &/| for vectors and data filtering, &&/|| for if() conditions. And since R 4.3, this is enforced with teeth: handing && or || a vector of length greater than 1 is an error (older R versions silently used just the first element, which hid real bugs for years).

xor(a, b) rounds out the set - TRUE when exactly one of the two is TRUE:

print(xor(TRUE, FALSE))  # TRUE
print(xor(TRUE, TRUE))   # FALSE

%in%: Membership Testing

x %in% table asks, for each element of x, "does this appear anywhere in table?" It's one of the most-used operators in real R code:

basket <- c("apple", "banana", "cherry")

print("banana" %in% basket)   # TRUE
print("mango" %in% basket)    # FALSE

wanted <- c("cherry", "mango", "apple")
print(wanted %in% basket)     # TRUE FALSE TRUE

The side being tested can be a whole vector, which makes %in% the natural tool for filtering rows by a set of allowed values.

It also beats the alternative you'd otherwise write - a chain of == glued together with |:

day <- "sat"

print(day == "sat" | day == "sun")   # works, but scales badly
print(day %in% c("sat", "sun"))      # same answer, stays readable

With five allowed values, the == chain becomes a wall of repetition; the %in% version just grows the vector. There's a second, subtler advantage - %in% never returns NA:

print(NA == 1)             # NA - comparison with a missing value is unknown
print(NA %in% c(1, 2, 3))  # FALSE - %in% gives a definite answer

NA == 1 is NA because R can't know whether an unknown value equals 1 - a behavior covered in depth in missing values. That NA then poisons any if() it reaches. %in% sidesteps the whole problem by always answering TRUE or FALSE, which is why it's the safer choice for conditions on possibly-missing data.

Precedence Gotchas

Two operator-precedence traps account for a disproportionate share of "R is broken" moments. First, ^ binds tighter than unary minus:

print(-2^2)     # -4  - parsed as -(2^2)
print((-2)^2)   #  4  - the square of negative two

Second, the colon binds tighter than binary arithmetic:

n <- 5

print(1:n - 1)     # 0 1 2 3 4  - parsed as (1:n) - 1
print(1:(n - 1))   # 1 2 3 4    - probably what you meant

When in doubt, add parentheses. They cost nothing and every reader (including future you) parses them the same way the interpreter does.

$ and [ ]: the Access Operators

You'll also constantly see $, [ ], and [[ ]] - technically operators too, used for pulling values out of structures rather than computing with them:

person <- list(name = "Rosa", age = 30)

print(person$name)     # by name, with $
print(person[["age"]]) # by name, with [[ ]]

They get full coverage in the pages on vectors, lists, and data frames - here it's enough to recognize them as members of the same operator family.

What You Take Away

• %% gives the remainder, %/% the whole-number quotient; x %% 2 == 0 tests evenness.
• Comparisons are vectorized - they return a logical vector you can filter with.
• &/| combine vectors element by element; &&/|| are for single values in if() and short-circuit. Since R 4.3, && on a longer vector is an error.
• x %in% table replaces chained == and never returns NA.
• -2^2 is -4 and 1:n - 1 starts at 0 - parenthesize when in doubt.

Next up: putting these operators to work inside if, else and ifelse() - R's conditional statements.