Números em R: Numeric, Integer e Funções Matemáticas

Numeric e Integer: Os Dois Tipos Numéricos de R

R armazena números de duas formas. Numeric (armazenado como float de precisão dupla) é o padrão - todo número que você digita é um double, a menos que você diga o contrário. Integer é um tipo separado de número inteiro exato que você solicita com o sufixo L:

x <- 3.14
n <- 42L

cat(typeof(x), typeof(n), "\n")
cat(class(x), class(n), "\n")

Na prática, você raramente precisa se importar: R converte entre eles silenciosamente, e is.numeric() é TRUE para ambos (veja tipos de dados para o sistema de tipos completo). O único lugar em que a distinção aparece é na divisão - / sempre retorna um double, mesmo entre dois integers:

cat(7L / 2L, "\n")
cat(typeof(7L / 2L), "\n")

Integers aparecem principalmente como saída de funções de contagem (length(), seq_len(), nrow()) e como valores de índice. Quando você precisa de divisão de números inteiros, R tem um operador dedicado - coberto mais abaixo.

A Família de Arredondamento

R oferece cinco maneiras de aparar um número, cada uma com um significado distinto:

cat(round(3.14159, 2), "\n")
cat(floor(2.7), "\n")
cat(ceiling(2.1), "\n")
cat(trunc(-2.7), "\n")
cat(signif(123456, 2), "\n")

• round(x, digits) - para um número de casas decimais (padrão 0).
• floor(x) - para baixo, até o inteiro mais próximo, sempre em direção ao infinito negativo.
• ceiling(x) - para cima, sempre em direção ao infinito positivo.
• trunc(x) - corta os decimais, sempre em direção ao zero. Repare na diferença com negativos: trunc(-2.7) é -2, mas floor(-2.7) é -3.
• signif(x, digits) - para um número de algarismos significativos, não de casas decimais: signif(123456, 2) é 120000.

E uma surpresa famosa: round() usa arredondamento para o par mais próximo (arredondamento bancário) em metades exatas, conforme o padrão IEEE 754:

cat(round(0.5), round(1.5), round(2.5), round(3.5), "\n")

Isso imprime 0 2 2 4 - cada metade arredonda para o número par mais próximo. Não é um bug; isso evita viés sistemático para cima quando você soma muitos valores arredondados. Se um relatório precisa do arredondamento de escola, adicione um pequeno ajuste ou formate na camada de apresentação.

Funções Matemáticas do Dia a Dia

O básico funciona exatamente como você imagina:

cat(sqrt(16), "\n")
cat(abs(-7.5), "\n")
cat(2^10, "\n")
cat(round(exp(1), 6), "\n")

sqrt() é a raiz quadrada, abs() o valor absoluto, ^ é exponenciação, e exp(x) é e elevado a x - portanto exp(1) é o número de Euler, cerca de 2,718282.

A função que confunde as pessoas é log(). Em R, log() é o logaritmo natural (base e), não base 10:

cat(log(100), "\n")
cat(log10(100), "\n")
cat(log2(8), "\n")
cat(log(8, base = 2), "\n")

A primeira linha imprime aproximadamente 4.60517 - não o 2 que quem pensa em base 10 espera. Recorra a log10() e log2() quando quiser essas bases, ou passe base = explicitamente. (Essa convenção é padrão na estatística, onde o logaritmo natural é o default.)

Módulo %% e Divisão Inteira %/%

Dois operadores cobrem a aritmética de resto:

cat(17 %% 5, "\n")
cat(17 %/% 5, "\n")

%% é o módulo (resto): 17 dividido por 5 é 3 com resto 2. %/% é a divisão inteira: quantos 5 inteiros cabem em 17. Juntos, eles satisfazem x == (x %/% y) * y + (x %% y).

O uso clássico de %% é testar divisibilidade:

n <- 12
cat(n %% 2 == 0, "\n")
cat(n %% 5 == 0, "\n")

Uma sutileza com números negativos: o %% de R assume o sinal do divisor (como Python, ao contrário de C):

cat(-7 %% 3, "\n")

Isso dá 2, não -1 - R responde "o que eu somo a um múltiplo de 3 para chegar a -7?", o que mantém os resultados em 0..2 para um divisor positivo. Prático para índices circulares; surpreendente se você vem de C ou Java.

Valores Especiais: Inf, -Inf e NaN

Os números de R seguem o IEEE 754, então algumas operações produzem valores especiais em vez de erros:

cat(1 / 0, "\n")
cat(-1 / 0, "\n")
cat(0 / 0, "\n")

1/0 é Inf (infinito), -1/0 é -Inf, e 0/0 - uma quantidade genuinamente indefinida - é NaN, "not a number". A distinção importa: Inf é uma resposta ("maior que qualquer coisa"), NaN é a ausência de uma. Você os testa com funções dedicadas, porque == NaN nunca funciona:

cat(is.infinite(1 / 0), "\n")
cat(is.nan(0 / 0), "\n")
cat(is.na(0 / 0), "\n")

Repare na última linha: NaN também conta como NA, então is.na() o captura - mais um motivo pelo qual is.na() é a verificação padrão de "este valor é inutilizável?" (mais em valores ausentes).

R também lê e escreve notação científica nativamente - 2.5e3 é 2500, e números muito pequenos ou muito grandes são impressos em notação com "e" por padrão:

cat(2.5e3, "\n")
cat(1e-4, "\n")
cat(format(1e-4, scientific = FALSE), "\n")

Use format(x, scientific = FALSE) (ou a opção scipen) quando um relatório precisar de decimais comuns.

A Surpresa do Ponto Flutuante

Toda linguagem que armazena decimais em binário compartilha esta, e R não é exceção:

cat(0.1 + 0.2 == 0.3, "\n")
print(0.1 + 0.2, digits = 17)

FALSE - porque 0.1 + 0.2 é na verdade 0.30000000000000004. Nem 0.1 nem 0.2 têm representação binária exata, e os pequenos erros se acumulam. A impressão padrão de R esconde isso ao mostrar 7 algarismos significativos, e é por isso que o problema parece invisível até uma comparação com == falhar.

A regra: nunca compare decimais calculados com ==. Use all.equal(), que compara dentro de uma tolerância razoável:

cat(isTRUE(all.equal(0.1 + 0.2, 0.3)), "\n")

Envolva em isTRUE() porque all.equal() retorna uma descrição da diferença (não FALSE) quando os valores diferem. Para trabalho com números inteiros em que a exatidão importa, integers são exatos até cerca de 2,1 bilhões - mais um motivo pelo qual código de contagem usa o tipo integer.

O Que Você Leva Daqui

• Todo número digitado é um double; 42L cria um integer, e / retorna um double de qualquer forma.
• round() arredonda metades para o par; floor/ceiling/trunc/signif aparam cada um de um jeito - saiba qual você quer dizer.
• log() é o logaritmo natural; use log10(), log2() ou base = para outras bases.
• %% dá o resto (o sinal segue o divisor), %/% o quociente inteiro.
• 1/0 é Inf, 0/0 é NaN, e 0.1 + 0.2 != 0.3 - compare decimais com all.equal(), nunca com ==.

A seguir: a outra metade dos dados do dia a dia - strings, e as funções que R oferece para construí-las, formatá-las e pesquisá-las.