Quais operadores lógicos estão disponíveis em R? O que cada um faz?

Passo 1

O enunciado pede que eu liste os operadores lógicos disponíveis em R e explique o que cada um faz. Não há outros dados fornecidos além da própria pergunta. Vou apresentar: (1) os operadores sintáticos principais (símbolos e funções que produzem valores lógicos), (2) como eles se comportam com vetores, com valores ausentes ( \text{NA}) e com expressões de controle, e (3) exemplos práticos para cada caso.

Passo 2

Vou primeiro listar, de maneira curta, os operadores que vou explicar detalhadamente depois:
  • Negação: \texttt{!}
  • E (element-wise): \texttt{\&}
  • Ou (element-wise): \texttt{|}
  • E curto-circuito (apenas o primeiro elemento): \texttt{\&\&}
  • Ou curto-circuito (apenas o primeiro elemento): \texttt{||}
  • Ou-exclusivo (element-wise): \texttt{xor(x,y)}
  • Pertinência/membro: \texttt{\%in\%}
  • Operadores relacionais (produzem lógicos): \texttt{==},\\ \texttt{!=},\\ \texttt{<},\\ \texttt{>},\\ \texttt{<=},\\ \texttt{>=}
    Além disso, mencionarei funções relacionadas que frequentemente são usadas com lógicos: \texttt{any()},\\ \texttt{all()},\\ \texttt{is.na()},\\ \texttt{is.nan()},\\ \texttt{isTRUE()},\\ \texttt{identical()}.

Passo 3

Negação: \texttt{!}
  • O que faz: é um operador unário que inverte valores lógicos. \texttt{!TRUE} resulta em \text{FALSE} e \texttt{!FALSE} resulta em \text{TRUE}.
  • Vetores: é vetorizado; aplica-se a cada elemento. Ex.: \texttt{!}\,\text{c}(\text{TRUE},\text{FALSE}) \text{c}(\text{FALSE},\text{TRUE}).
  • \text{NA}: \texttt{!NA} resulta em \text{NA} (não se pode decidir a negação de algo desconhecido).

Passo 4

E/OU element-wise: \texttt{\&} e \texttt{|}
  • O que fazem: comparam elemento a elemento dois vetores lógicos (ou coeríveis para lógicos) e retornam um vetor lógico do mesmo comprimento (após reciclagem, se aplicável).
    • \texttt{\&} é o “E” lógico: cada posição só é \text{TRUE} se ambos os operandos nessa posição forem \text{TRUE}.
    • \texttt{|} é o “OU” lógico: cada posição é \text{TRUE} se pelo menos um dos operandos nessa posição for \text{TRUE}.
  • Exemplos:
    • \texttt{c(TRUE, FALSE) \& c(TRUE, TRUE)} resulta em \text{c(TRUE, FALSE)}.
    • \texttt{c(TRUE, FALSE) | c(FALSE, TRUE)} resulta em \text{c(TRUE, TRUE)}.
  • NA e reciclagem:
    • Se um elemento for \text{NA} e a outra entrada na mesma posição não permitir decidir o resultado, o resultado será \text{NA}. Ex.: \texttt{FALSE \& NA} resulta em \text{NA} (porque \texttt{\&} não faz curto-circuito e avalia ambos).
    • Reciclagem: se comprimentos diferentes, R recicla o menor; atenção a avisos quando o comprimento não é múltiplo.

Passo 5

E/OU curto-circuito: \texttt{\&\&} e \texttt{||}
  • O que fazem: fazem avaliação apenas do primeiro elemento de cada operando e são usados tipicamente em expressões de controle (por exemplo em \texttt{if(...)}).
    • \texttt{\&\&} é “E” com curto-circuito: avalia o primeiro elemento da esquerda; se for \text{FALSE}, não avalia a direita e retorna \text{FALSE}.
    • \texttt{||} é “OU” com curto-circuito: avalia o primeiro elemento da esquerda; se for \text{TRUE}, não avalia a direita e retorna \text{TRUE}.
  • Importante: eles retornam um único valor lógico de comprimento 1.
  • Exemplo prático e comportamento com \text{NA}:
    • \texttt{FALSE \&\& NA} resulta em \text{FALSE} (não avalia \text{NA} pelo curto-circuito).
    • \texttt{TRUE || NA} resulta em \text{TRUE}.

Passo 6

Ou-exclusivo: \texttt{xor(x,y)}
  • O que faz: função element-wise que retorna \text{TRUE} quando exatamente um dos argumentos é \text{TRUE} (ou seja, \text{TRUE} se e somente se os valores forem diferentes, mas tratando \text{NA} com cautela).
  • Vetores: aceita vetores (aplica reciclagem se necessário) e retorna vetor lógico.
  • \text{NA}: se em uma posição o resultado não puder ser decidido por causa de \text{NA}, o resultado será \text{NA}. Ex.: \texttt{xor(TRUE, NA)} \text{NA}.

Passo 7

Operador de pertinência: \texttt{\%in\%}
  • O que faz: verifica para cada elemento do primeiro vetor se ele aparece em (é membro de) o segundo vetor; retorna vetor lógico do comprimento do primeiro.
  • Exemplo: \texttt{c(1,2,3) \%in\% c(2,3,4)} resulta em \text{c(FALSE, TRUE, TRUE)}.
  • Útil em filtros e seleção de dados; é vetorizado.

Passo 8

Operadores relacionais (produzem valores lógicos): \texttt{==},\\ \texttt{!=},\\ \texttt{<},\\ \texttt{>},\\ \texttt{<=},\\ \texttt{>=}
  • O que fazem: comparam valores (numéricos, caractere, factor, etc.) elemento a elemento e retornam um vetor lógico.
  • Exemplo: \texttt{c(1,2,3) > 1} resulta em \text{c(FALSE, TRUE, TRUE)}.
  • Atenção com igualdade de números de ponto flutuante; para comparar numericamente, costuma-se usar \texttt{all.equal()} ou tolerância relativa em vez de \texttt{==} direto.
  • \text{NA} nas comparações gera \text{NA} nas posições correspondentes.

Passo 9

Funções utilitárias que trabalham com lógicos (muito usadas)
  • \texttt{any(x)}: retorna \text{TRUE} se pelo menos um elemento de \texttt{x} for \text{TRUE} (caso contrário \text{FALSE}; \text{NA} gera \text{NA} se não for possível decidir).
  • \texttt{all(x)}: retorna \text{TRUE} se todos os elementos de \texttt{x} forem \text{TRUE}.
  • \texttt{is.na(x)}: retorna vetor lógico indicando onde há \text{NA}.
  • \texttt{is.nan(x)}: identifica \text{NaN} (não é igual a \text{NA}).
  • \texttt{isTRUE(x)}: devolve \text{TRUE} somente se \texttt{x} for exatamente \text{TRUE} (comprimento 1, não \text{NA}).
  • \texttt{identical(a,b)}: testa igualdade estrita entre objetos, retornando \text{TRUE} ou \text{FALSE}.

Passo 10

Comportamentos práticos, precedência e armadilhas comuns
  • Precedência (regra prática): a negação \texttt{!} é aplicada antes das operações binárias; operações relacionais ocorrem antes de \texttt{\&} e \texttt{|}. Quando tiver dúvidas, use parênteses para deixar a ordem explícita.
  • Curto-circuito vs element-wise: use \texttt{\&\&}/ \texttt{||} em condições (por exemplo em \texttt{if()}) quando só importa o primeiro elemento; use \texttt{\&}/ \texttt{|} quando quiser comparar vetores inteiros.
  • NA: preste atenção — \texttt{\&} e \texttt{|} não fazem curto-circuito, então \texttt{FALSE \& NA} \text{NA}, enquanto \texttt{FALSE \&\& NA} \text{FALSE}.
  • Tipos: operadores lógicos esperam valores lógicos; números podem ser convertidos com \texttt{as.logical()} ( \texttt{0}\rightarrow\text{FALSE}, \texttt{1}\rightarrow\text{TRUE}), mas é mais seguro fazer comparações explícitas para gerar lógicos.
  • Uso em filtros: combinando operadores relacionais com \texttt{\&}, \texttt{|} e \texttt{\%in\%} é a forma típica de criar máscaras lógicas para indexação de vetores/data.frames.

Passo 11

Exemplos rápidos (resumo prático)
  • Negação: \texttt{!TRUE} \text{FALSE}.
  • Element-wise E: \texttt{c(TRUE, FALSE) \& c(TRUE, TRUE)} \text{c(TRUE, FALSE)}.
  • Element-wise OU: \texttt{c(TRUE, FALSE) | c(FALSE, TRUE)} \text{c(TRUE, TRUE)}.
  • Curto-circuito: \texttt{FALSE \&\& NA} \text{FALSE} ; \texttt{FALSE \& NA} \text{NA}.
  • XOR: \texttt{xor(c(TRUE,FALSE), c(FALSE,TRUE))} \text{c(TRUE,TRUE)}.
  • Pertinência: \texttt{c(1,2,3) \%in\% c(2,3)} \text{c(FALSE, TRUE, TRUE)}.
  • Relacional: \texttt{c(1,2,3) > 1} \text{c(FALSE, TRUE, TRUE)}.
  • Redução: \texttt{any(c(FALSE, TRUE))} \text{TRUE}; \texttt{all(c(TRUE, NA))} \text{NA}.

Resposta

\texttt{!} — negação (unário, vetorizado).
\texttt{\&} — E lógico element-wise (vetorizado, avalia todos os elementos).
\texttt{|} — OU lógico element-wise (vetorizado, avalia todos os elementos).
\texttt{\&\&} — E lógico curto-circuito (avaliar somente o primeiro elemento; usado em condições; retorna comprimento 1).
\texttt{||} — OU lógico curto-circuito (avaliar somente o primeiro elemento; usado em condições; retorna comprimento 1).
\texttt{xor(x,y)} — ou-exclusivo element-wise (TRUE se exatamente um dos argumentos for TRUE).
\texttt{\%in\%} — teste de pertinência/membro (retorna vetor lógico indicando se cada elemento do primeiro aparece no segundo).
\texttt{==},\\ \texttt{!=},\\ \texttt{<},\\ \texttt{>},\\ \texttt{<=},\\ \texttt{>=} — operadores relacionais que retornam valores lógicos.
Funções relacionadas úteis: \texttt{any()},\\ \texttt{all()},\\ \texttt{is.na()},\\ \texttt{is.nan()},\\ \texttt{isTRUE()},\\ \texttt{identical()}.

Exercícios relacionados