R Comparison Operators: ==, !=, <, >, <=, >= Guide

R has six comparison operators that return TRUE or FALSE: == (equal), != (not equal), <, >, <=, >=. They are vectorized, so they work element-wise on whole vectors.

x == y                       # equal (CAREFUL with floats)
x != y                       # not equal
x < y; x > y                 # less than, greater than
x <= y; x >= y               # less or equal, greater or equal
x %in% c(1, 2, 3)            # set membership
identical(x, y)              # exact equality (better than == for objects)
all.equal(x, y)              # near equality (use for floats)

What R's comparison operators do in one sentence

Each comparison operator returns a logical vector the same length as the longer input, with TRUE where the comparison holds and FALSE where it does not. They are vectorized: c(1, 2, 3) > 2 returns c(FALSE, FALSE, TRUE).

For exact equality between objects (lists, models, complex types), use identical(x, y) instead of x == y. For floating-point comparisons, use all.equal(x, y) instead of ==.

Syntax

All six operators take two values (or vectors) and return TRUE/FALSE. They recycle the shorter vector if lengths differ.

Six common patterns

1. Equality and inequality

== returns TRUE for matches; != is its negation.

2. Range comparisons

Combine > and < with & for ranges. dplyr's between(x, 10, 25) is more readable for inclusive ranges.

3. Floating-point trap

Floating-point representation is approximate. Two values that look equal may differ by tiny amounts. ALWAYS use all.equal() for float comparisons or abs(x - y) < tolerance with an explicit tolerance.

4. Membership with %in%

%in% is the readable way to test "is x one of these values". Equivalent to chained == connected by | but cleaner.

5. NA propagation

NA > 2 is NA (the unknown could be anything). To handle NAs in comparisons, combine with is.na() or use coalesce() from dplyr.

6. identical() vs == for objects

== does NOT work on lists. identical() is the correct way to test deep equality between any R objects (lists, environments, functions, S4 objects).

R comparison operators reference

The six basic operators plus three companion functions cover every common comparison need in R. Vectorized by default; use companion functions for object-level or float-aware checks.

When to use which:

• Use == and friends for vectorized element comparisons.
• Use identical() to compare whole R objects.
• Use all.equal() for floating-point near-equality.
• Use %in% for "is x one of these values".

Common pitfalls

Pitfall 1: comparing floats with ==. 0.1 + 0.2 == 0.3 returns FALSE due to floating-point representation. Use all.equal() or abs(diff) < tolerance.

Pitfall 2: == on factors. Comparing factors to strings often fails because factor equality compares LEVEL INTEGERS, not strings. Convert factor to character first: as.character(factor_var) == "value".

Pitfall 3: assuming == works on lists. It does not. list(1, 2) == list(1, 2) errors. Use identical() for object equality.

Try it yourself

Related R functions

After mastering comparison operators, look at:

• identical(): deep object equality
• all.equal(): near equality with tolerance
• near() (dplyr): readable wrapper for float near-equality
• is.na(), is.null(): tests for special values
• between() (dplyr): inclusive range check
• %in%: set membership
• Negate(): function-level negation (Negate(is.na) returns the inverse)

For string comparisons with case-insensitivity or pattern matching, use tolower(), grepl(), or stringr::str_detect().

FAQ

What is the difference between == and identical() in R?

== is vectorized element-wise comparison; returns a logical VECTOR. identical() returns a single TRUE/FALSE for whether two whole R objects are exactly equal (same type, same value, same structure). Use == for element-wise; identical() for whole-object comparison.

Why does 0.1 + 0.2 != 0.3 in R?

Floating-point representation is approximate. The true result of 0.1 + 0.2 is 0.30000000000000004, not 0.3. The == operator detects this tiny difference. Use all.equal(0.1 + 0.2, 0.3) (returns TRUE) or abs(diff) < tolerance.

How do I check if a value is in a set in R?

Use %in%: x %in% c(1, 2, 3) returns TRUE if x is one of 1, 2, or 3. Negate with !: !(x %in% c(1, 2, 3)). More readable than chained == connected by |.

What does == NA return in R?

NA. Comparing anything with NA returns NA, including NA == NA. To test for NA, use is.na(x). To filter NAs out: x[!is.na(x)].

How do I compare floating-point numbers in R?

Never with ==. Use all.equal(x, y) for a tolerance-aware test (returns TRUE or a description of the difference). Or abs(x - y) < tolerance with an explicit tolerance like 1e-8. dplyr provides near(x, y, tol = ...) as a readable wrapper.