Operadores en R: aritméticos, de comparación, lógicos, %in% y %%

Los operadores que te da R

Los operadores de R se agrupan en cuatro familias de trabajo: aritméticos (+ - * / ^ %% %/%), de comparación (== != < <= > >=), lógicos (& | && || ! xor) y la comprobación de pertenencia %in%. Dos cosas los diferencian de la mayoría de lenguajes: casi todos están vectorizados - operan sobre vectores enteros de una vez, elemento a elemento - y R tiene dos operadores AND y dos operadores OR que no son intercambiables. Esta página los cubre todos, además de las trampas de precedencia que producen respuestas silenciosamente incorrectas.

Aritméticos: +, -, *, /, ^, %% y %/%

Los cinco primeros hacen lo que esperas. Los dos envueltos en porcentajes - %% (módulo, el resto) y %/% (división entera, el cociente) - son los que la gente busca:

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

Fíjate en que / siempre hace división en coma flotante - 17 / 5 es 3.4, nunca 3. Si quieres la parte entera, para eso está exactamente %/%.

El trabajo cotidiano de %% es la divisibilidad. Un número es par cuando al dividirlo entre 2 no deja resto:

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

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

Esa segunda línea merece una pausa: con un operando negativo, el %% de R devuelve un resultado con el signo del divisor (-7 %% 3 es 2, porque -7 = -3 * 3 + 2). Algunos lenguajes lo hacen al revés; si estás portando código, compruébalo.

Los operadores de comparación están vectorizados

==, !=, <, <=, >, >= comparan elemento a elemento y devuelven un vector lógico, no una única respuesta:

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

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

Este es el motor detrás de casi todo el filtrado en R - comparas un vector entero contra un valor, obtienes una máscara lógica y usas la máscara para hacer el subconjunto. Una advertencia sobre == con decimales: los números en coma flotante se almacenan de forma aproximada, así que 0.1 + 0.2 == 0.3 es FALSE. Para comparar decimales, prefiere all.equal() o comprueba abs(x - y) < 1e-9.

Operadores lógicos: & frente a && (la confusión clásica)

R tiene dos operadores AND y dos operadores OR, y elegir el equivocado es un rito de paso.

& y | están vectorizados. Combinan dos vectores lógicos elemento a elemento:

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

Úsalos siempre que estés construyendo un filtro sobre datos: df[df$age > 30 & df$city == "Lisbon", ].

&& y || son escalares y hacen cortocircuito. Toman valores individuales, devuelven un único TRUE/FALSE y se saltan por completo el segundo operando si el primero ya resuelve la respuesta:

x <- 8

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

Esa segunda línea demuestra el cortocircuito: como x < 0 es FALSE, R nunca evalúa la llamada a stop(). Por eso exactamente && pertenece a las condiciones if() - puedes escribir if (!is.na(x) && x > 10) y la parte x > 10 se salta con seguridad cuando x es NA.

La regla general: &/| para vectores y filtrado de datos, &&/|| para condiciones if(). Y desde R 4.3 esto se impone con dientes: pasarle a && o || un vector de longitud mayor que 1 es un error (las versiones antiguas de R usaban en silencio solo el primer elemento, lo que ocultó errores reales durante años).

xor(a, b) completa el conjunto - TRUE cuando exactamente uno de los dos es TRUE:

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

%in%: comprobar pertenencia

x %in% table pregunta, para cada elemento de x: "¿aparece esto en algún lugar de table?". Es uno de los operadores más usados en el código real de R:

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

El lado que se comprueba puede ser un vector entero, lo que convierte a %in% en la herramienta natural para filtrar filas por un conjunto de valores permitidos.

También gana a la alternativa que si no escribirías - una cadena de == pegados con |:

day <- "sat"

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

Con cinco valores permitidos, la cadena de == se convierte en un muro de repetición; la versión con %in% solo hace crecer el vector. Hay una segunda ventaja, más sutil: %in% nunca devuelve 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 es NA porque R no puede saber si un valor desconocido es igual a 1 - un comportamiento cubierto a fondo en valores ausentes. Ese NA luego envenena cualquier if() al que llegue. %in% esquiva todo el problema respondiendo siempre TRUE o FALSE, y por eso es la opción más segura para condiciones sobre datos que podrían faltar.

Trampas de precedencia

Dos trampas de precedencia de operadores explican una parte desproporcionada de los momentos "R está roto". Primera: ^ tiene más precedencia que el menos unario:

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

Segunda: los dos puntos tienen más precedencia que la aritmética binaria:

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

Ante la duda, añade paréntesis. No cuestan nada y cualquier lector (incluido tu yo futuro) los interpreta igual que el intérprete.

$ y [ ]: los operadores de acceso

También verás constantemente $, [ ] y [[ ]] - técnicamente también operadores, usados para extraer valores de estructuras en lugar de para calcular con ellos:

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

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

Se cubren a fondo en las páginas sobre vectores, listas y data frames - aquí basta con reconocerlos como miembros de la misma familia de operadores.

Lo que te llevas

• %% da el resto, %/% el cociente entero; x %% 2 == 0 comprueba si es par.
• Las comparaciones están vectorizadas - devuelven un vector lógico con el que puedes filtrar.
• &/| combinan vectores elemento a elemento; &&/|| son para valores individuales en if() y hacen cortocircuito. Desde R 4.3, && sobre un vector más largo es un error.
• x %in% table sustituye a los == encadenados y nunca devuelve NA.
• -2^2 es -4 y 1:n - 1 empieza en 0 - pon paréntesis ante la duda.

Lo siguiente: poner estos operadores a trabajar dentro de if, else e ifelse() - las sentencias condicionales de R.