Operadores em R: Aritméticos, de Comparação, Lógicos, %in% e %%

Os Operadores que o R Oferece

Os operadores do R se dividem em quatro grupos de trabalho: aritméticos (+ - * / ^ %% %/%), de comparação (== != < <= > >=), lógicos (& | && || ! xor) e o teste de pertencimento %in%. Duas coisas os diferenciam da maioria das linguagens: quase todos são vetorizados - operam sobre vetores inteiros de uma vez, elemento a elemento - e o R tem dois operadores E e dois operadores OU que não são intercambiáveis. Esta página cobre todos eles, além das armadilhas de precedência que produzem respostas silenciosamente erradas.

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

Os cinco primeiros fazem o que você espera. Os dois envoltos em porcentagem - %% (módulo, o resto) e %/% (divisão inteira, o quociente) - são os que as pessoas pesquisam:

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 que / sempre faz divisão de ponto flutuante - 17 / 5 é 3.4, nunca 3. Se você quer a parte inteira, é exatamente para isso que serve %/%.

O trabalho cotidiano de %% é a divisibilidade. Um número é par quando a divisão por 2 não deixa resto:

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

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

Essa segunda linha merece uma pausa: com um operando negativo, o %% do R retorna um resultado com o sinal do divisor (-7 %% 3 é 2, porque -7 = -3 * 3 + 2). Algumas linguagens fazem o contrário; se você está portando código, verifique.

Operadores de Comparação São Vetorizados

==, !=, <, <=, >, >= comparam elemento a elemento e retornam um vetor lógico, não uma resposta única:

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

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

Esse é o motor por trás de quase toda filtragem em R - você compara um vetor inteiro com um valor, obtém uma máscara lógica e usa a máscara para subconjuntos. Uma cautela com == em decimais: números de ponto flutuante são armazenados de forma aproximada, então 0.1 + 0.2 == 0.3 é FALSE. Para comparações decimais, prefira all.equal() ou verifique abs(x - y) < 1e-9.

Operadores Lógicos: & vs && (a Confusão Clássica)

O R tem dois operadores E e dois operadores OU, e escolher o errado é um rito de passagem.

& e | são vetorizados. Eles combinam dois vetores 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

Use-os sempre que estiver construindo um filtro sobre dados: df[df$age > 30 & df$city == "Lisbon", ].

&& e || são escalares e fazem curto-circuito. Eles recebem valores únicos, retornam um único TRUE/FALSE e pulam o segundo operando por completo se o primeiro já resolve a resposta:

x <- 8

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

Essa segunda linha demonstra o curto-circuito: como x < 0 é FALSE, o R nunca avalia a chamada a stop(). É exatamente por isso que && pertence às condições de if() - você pode escrever if (!is.na(x) && x > 10) e a parte x > 10 é pulada com segurança quando x é NA.

A regra prática: &/| para vetores e filtragem de dados, &&/|| para condições de if(). E desde o R 4.3 isso é imposto com rigor: entregar a && ou || um vetor de comprimento maior que 1 é um erro (versões mais antigas do R usavam silenciosamente apenas o primeiro elemento, o que escondeu bugs reais por anos).

xor(a, b) completa o conjunto - TRUE quando exatamente um dos dois é TRUE:

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

%in%: Teste de Pertencimento

x %in% table pergunta, para cada elemento de x, "isto aparece em algum lugar de table?" É um dos operadores mais usados em código R do mundo real:

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

O lado testado pode ser um vetor inteiro, o que faz de %in% a ferramenta natural para filtrar linhas por um conjunto de valores permitidos.

Ele também supera a alternativa que você escreveria em seu lugar - uma cadeia de == colada com |:

day <- "sat"

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

Com cinco valores permitidos, a cadeia de == vira um paredão de repetição; a versão com %in% só faz o vetor crescer. Há uma segunda vantagem, mais sutil - %in% nunca retorna 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 é NA porque o R não tem como saber se um valor desconhecido é igual a 1 - um comportamento tratado em profundidade em valores ausentes. Esse NA então envenena qualquer if() que ele alcance. %in% contorna o problema inteiro respondendo sempre TRUE ou FALSE, e é por isso que é a escolha mais segura para condições sobre dados possivelmente ausentes.

Pegadinhas de Precedência

Duas armadilhas de precedência de operadores respondem por uma parcela desproporcional dos momentos "o R está quebrado". Primeiro, ^ tem precedência maior que o menos unário:

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

Segundo, o dois-pontos tem precedência maior que a aritmética binária:

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

Na dúvida, adicione parênteses. Eles não custam nada e todo leitor (incluindo o você do futuro) os interpreta da mesma forma que o interpretador.

$ e [ ]: os Operadores de Acesso

Você também verá constantemente $, [ ] e [[ ]] - tecnicamente operadores também, usados para extrair valores de estruturas em vez de computar com eles:

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

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

Eles recebem cobertura completa nas páginas sobre vetores, listas e data frames - aqui basta reconhecê-los como membros da mesma família de operadores.

O Que Você Leva Daqui

• %% dá o resto, %/% o quociente inteiro; x %% 2 == 0 testa se um número é par.
• Comparações são vetorizadas - retornam um vetor lógico com o qual você pode filtrar.
• &/| combinam vetores elemento a elemento; &&/|| são para valores únicos em if() e fazem curto-circuito. Desde o R 4.3, && com um vetor mais longo é um erro.
• x %in% table substitui == encadeados e nunca retorna NA.
• -2^2 é -4 e 1:n - 1 começa em 0 - use parênteses na dúvida.

A seguir: colocando esses operadores para trabalhar dentro de if, else e ifelse() - as estruturas condicionais do R.