Números en R: numeric, integer y funciones matemáticas

Numeric e integer: los dos tipos numéricos de R

R almacena los números de dos maneras. Numeric (almacenado como coma flotante de doble precisión) es el tipo por defecto - cada número que escribes es un double a menos que digas lo contrario. Integer es un tipo separado de entero exacto que pides con el sufijo L:

x <- 3.14
n <- 42L

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

En la práctica rara vez necesitas preocuparte: R convierte entre ellos en silencio, y is.numeric() es TRUE para ambos (mira tipos de datos para el sistema de tipos completo). El único lugar donde la distinción se nota es la división - / siempre devuelve un double, incluso entre dos integers:

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

Los integers aparecen sobre todo como salida de funciones de conteo (length(), seq_len(), nrow()) y como valores de índice. Cuando necesites división de números enteros, R tiene un operador dedicado - cubierto más abajo.

La familia de redondeo

R te da cinco formas de recortar un número, cada una con un 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) - a un número de decimales (por defecto 0).
• floor(x) - hacia abajo al entero más cercano, siempre hacia el infinito negativo.
• ceiling(x) - hacia arriba, siempre hacia el infinito positivo.
• trunc(x) - corta los decimales, siempre hacia cero. Fíjate en la diferencia con los negativos: trunc(-2.7) es -2, pero floor(-2.7) es -3.
• signif(x, digits) - a un número de cifras significativas, no de decimales: signif(123456, 2) es 120000.

Y una sorpresa famosa: round() usa el redondeo al par más cercano (redondeo bancario) en las mitades exactas, según el estándar IEEE 754:

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

Eso imprime 0 2 2 4 - cada mitad se redondea al número par más cercano. No es un bug; evita un sesgo sistemático al alza cuando sumas muchos valores redondeados. Si un informe necesita el redondeo de la escuela, añade un pequeño empujón o formatea en la capa de presentación.

Funciones matemáticas del día a día

Lo básico funciona exactamente como imaginas:

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

sqrt() es la raíz cuadrada, abs() el valor absoluto, ^ es la potenciación, y exp(x) es e elevado a x - así que exp(1) es el número de Euler, aproximadamente 2.718282.

La función que hace tropezar a la gente es log(). En R, log() es el logaritmo natural (base e), no base 10:

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

La primera línea imprime aproximadamente 4.60517 - no el 2 que espera un lector de base 10. Recurre a log10() y log2() cuando quieras esas bases, o pasa base = explícitamente. (Esta convención es estándar en estadística, donde el logaritmo natural es el predeterminado.)

Módulo %% y división entera %/%

Dos operadores cubren la aritmética de restos:

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

%% es el módulo (resto): 17 dividido entre 5 es 3 con resto 2. %/% es la división entera: cuántos 5 completos caben en 17. Juntos satisfacen x == (x %/% y) * y + (x %% y).

El uso clásico de %% es comprobar la divisibilidad:

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

Una sutileza con los números negativos: el %% de R toma el signo del divisor (como Python, a diferencia de C):

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

Eso es 2, no -1 - R responde a "¿qué le sumo a un múltiplo de 3 para llegar a -7?", lo que mantiene los resultados en 0..2 para un divisor positivo. Práctico para envolver índices; sorprendente si vienes de C o Java.

Valores especiales: Inf, -Inf y NaN

Los números de R siguen IEEE 754, así que algunas operaciones producen valores especiales en lugar de errores:

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

1/0 es Inf (infinito), -1/0 es -Inf, y 0/0 - una cantidad genuinamente indefinida - es NaN, "not a number". La distinción importa: Inf es una respuesta ("más grande que cualquier cosa"), NaN es la ausencia de una. Los compruebas con funciones dedicadas, porque == NaN nunca funciona:

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

Fíjate en la última línea: NaN también cuenta como NA, así que is.na() lo captura - una razón más por la que is.na() es la comprobación estándar de "¿es este valor inutilizable?" (más en valores ausentes).

R también lee y escribe notación científica de forma nativa - 2.5e3 es 2500, y los números muy pequeños o muy grandes se imprimen en notación e por defecto:

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

Usa format(x, scientific = FALSE) (o la opción scipen) cuando un informe necesite decimales normales.

La sorpresa de la coma flotante

Todos los lenguajes que almacenan decimales en binario comparten esta, y R no es la excepción:

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

FALSE - porque 0.1 + 0.2 es en realidad 0.30000000000000004. Ni 0.1 ni 0.2 tienen representación binaria exacta, y los pequeños errores se acumulan. La impresión por defecto de R lo oculta mostrando 7 dígitos significativos, por eso el problema parece invisible hasta que falla una comparación con ==.

La regla: nunca compares decimales calculados con ==. Usa all.equal(), que compara dentro de una tolerancia sensata:

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

Envuélvelo en isTRUE() porque all.equal() devuelve una descripción de la diferencia (no FALSE) cuando los valores difieren. Para trabajo con enteros donde la exactitud importa, los integers son exactos hasta unos 2.100 millones - otra razón por la que el código de conteo usa el tipo integer.

Lo que te llevas

• Cada número que escribes es un double; 42L crea un integer, y / devuelve un double en cualquier caso.
• round() redondea las mitades al par; floor/ceiling/trunc/signif recortan cada uno de forma distinta - sabe cuál quieres decir.
• log() es el logaritmo natural; usa log10(), log2() o base = para otras bases.
• %% da el resto (el signo sigue al divisor), %/% el cociente entero.
• 1/0 es Inf, 0/0 es NaN, y 0.1 + 0.2 != 0.3 - compara decimales con all.equal(), nunca con ==.

Lo siguiente: la otra mitad de los datos cotidianos - las cadenas, y las funciones que R te da para construirlas, formatearlas y buscar en ellas.