0Pricing
R Academy · Lección

Conversión entre tipos numéricos

Use as.integer(), as.double() y as.numeric() de forma segura.

Conversión entre tipos numéricos es una lección gratuita de R Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de R Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de R Academy incluye 4 lecciones en total.

Integer frente a Double en R

R tiene dos tipos numéricos: integer (números enteros, creados con el sufijo L) y double (coma flotante, el valor predeterminado para los literales numéricos). La mayoría de las veces R utiliza double, pero distinguirlos es importante para la seguridad de tipos y la eficiencia de memoria.

x_dbl <- 5        # double by default
x_int <- 5L       # integer (L suffix)

cat('typeof(5):  ', typeof(x_dbl), '
')  # double
cat('typeof(5L): ', typeof(x_int), '
')  # integer
cat('5 == 5L:    ', x_dbl == x_int, '
') # TRUE (values equal)
cat('identical:  ', identical(x_dbl, x_int), '
')  # FALSE (types differ)

as.integer() — Convertir a entero

as.integer(x) convierte un valor a entero mediante truncamiento (no redondeo) de la parte decimal. Esto significa que 3.9 se convierte en 3, no en 4. El sufijo L es una forma abreviada de la sintaxis para literales enteros.

cat('as.integer(3.7):  ', as.integer(3.7), '
')   # 3 (truncated, not 4)
cat('as.integer(3.2):  ', as.integer(3.2), '
')   # 3
cat('as.integer(-2.9): ', as.integer(-2.9), '
')  # -2 (toward zero)
cat('as.integer(10.9): ', as.integer(10.9), '
')  # 10

# Compare with round
cat('round(3.7):        ', round(3.7), '
')       # 4

as.double() y as.numeric()

as.double(x) y as.numeric(x) son equivalentes: ambas convierten el valor a double (coma flotante). Úselas para convertir enteros a doubles cuando necesite precisión fraccionaria.

count <- 7L  # integer
cat('typeof(count):         ', typeof(count), '
')

dbl_count <- as.double(count)
cat('typeof(as.double(7L)): ', typeof(dbl_count), '
')  # double
cat('Value:                 ', dbl_count, '
')           # 7

# Division automatically promotes to double
cat('7L / 2L:              ', 7L / 2L, '
')            # 3.5 (double)
cat('typeof(7L / 2L):      ', typeof(7L / 2L), '
')    # double

Aritmética con enteros

La aritmética con enteros en R produce enteros para +, - y *, pero siempre devuelve un double para /. Esto puede resultar inesperado si espera que la división entera conserve el tipo entero.

a <- 6L
b <- 3L

cat('6L + 3L =', a + b, '| typeof:', typeof(a + b), '
')  # 9 integer
cat('6L - 3L =', a - b, '| typeof:', typeof(a - b), '
')  # 3 integer
cat('6L * 3L =', a * b, '| typeof:', typeof(a * b), '
')  # 18 integer
cat('6L / 3L =', a / b, '| typeof:', typeof(a / b), '
')  # 2 DOUBLE!
cat('6L %/% 3L =', a %/% b, '| typeof:', typeof(a %/% b), '
') # 2 integer

Truncamiento frente a redondeo

Una distinción fundamental: as.integer() trunca (elimina los decimales), mientras que round() redondea al número entero más cercano. Especifique siempre con claridad qué comportamiento pretende.

values <- c(2.1, 2.5, 2.9, -2.1, -2.5, -2.9)

cat('Original:     ', values, '
')
cat('as.integer():  ', as.integer(values), '
')  # truncate toward 0
cat('round():       ', round(values), '
')       # banker rounding
cat('floor():       ', floor(values), '
')       # round down
cat('ceiling():     ', ceiling(values), '
')     # round up

Riesgo de desbordamiento de enteros

Los enteros en R son de 32 bits y pueden contener valores de hasta aproximadamente ±2.1 mil millones. Superar este intervalo produce un NA con una advertencia. Los doubles pueden contener valores mucho mayores (hasta ~1.8 × 10^308).

max_int <- .Machine$integer.max
cat('Max integer:', max_int, '
')  # 2147483647

# Overflow produces NA
cat('max_int + 1L:', max_int + 1L, '
')  # NA with warning

# Double handles it fine
cat('as.double(max_int) + 1:', as.double(max_int) + 1, '
')  # 2147483648

El sufijo L en los vectores

Puede crear vectores de enteros utilizando el sufijo L en cada elemento o pasando una secuencia a través de as.integer(). El operador de dos puntos : produce enteros automáticamente.

# Colon produces integers
seq_int <- 1:5
cat('1:5 typeof:', typeof(seq_int), '
')  # integer

# Explicit integer vector
vec_int <- c(10L, 20L, 30L, 40L)
cat('c(10L,...) typeof:', typeof(vec_int), '
')  # integer

# as.integer on a vector
vec_dbl <- c(1.1, 2.9, 3.5, 4.7)
cat('as.integer(c(1.1,...)):', as.integer(vec_dbl), '
')  # 1 2 3 4

Memoria y rendimiento

Los enteros utilizan 4 bytes por elemento; los doubles, 8 bytes. En vectores muy grandes de números enteros, utilizar enteros puede reducir a la mitad el uso de memoria. Sin embargo, las operaciones aritméticas entre tipos mixtos se convierten automáticamente a double.

n <- 1000000L

vec_int <- 1:n          # integer: 4 bytes each
vec_dbl <- as.double(1:n)  # double: 8 bytes each

cat('Integer vector size:', object.size(vec_int), 'bytes
')
cat('Double vector size: ', object.size(vec_dbl), 'bytes
')
cat('Ratio:', as.numeric(object.size(vec_dbl)) / as.numeric(object.size(vec_int)), '
')

Comprobación del almacenamiento entero con is.integer()

Utilice siempre is.integer() (no is.numeric()) cuando necesite verificar específicamente que el almacenamiento es entero. Un número sin el sufijo L es double, aunque parezca un número entero.

a <- 5    # looks like integer, but it is double
b <- 5L   # true integer

cat('is.integer(5):  ', is.integer(a), '
')   # FALSE!
cat('is.integer(5L): ', is.integer(b), '
')   # TRUE
cat('is.numeric(5):  ', is.numeric(a), '
')   # TRUE
cat('is.numeric(5L): ', is.numeric(b), '
')   # TRUE
cat('class(5):       ', class(a), '
')        # numeric
cat('class(5L):      ', class(b), '
')        # integer

Ejemplo de flujo de conversión

Un flujo de trabajo práctico: lea los datos como doubles (el valor predeterminado), realice los cálculos y, después, convierta explícitamente los resultados a enteros cuando se requieran números enteros (por ejemplo, en recuentos, índices o identificadores).

# Simulated: reading counts as doubles (common from CSV)
counts_raw <- c(12.0, 8.0, 15.0, 3.0, 22.0)
cat('typeof raw:', typeof(counts_raw), '
')  # double

# Convert to integer for proper storage
counts_int <- as.integer(counts_raw)
cat('typeof converted:', typeof(counts_int), '
')  # integer
cat('Counts:', counts_int, '
')
cat('Total:', sum(counts_int), '
')

Resumen de la conversión numérica

Funciones clave de conversión para tipos numéricos:

  • as.integer(x) — trunca a entero (elimina los decimales hacia cero)
  • as.double(x) / as.numeric(x) — convierte a double
  • round(x) — redondea al valor más cercano (úselo para valores similares a enteros)
  • floor(x) / ceiling(x) — redondea hacia abajo / hacia arriba
  • Sintaxis 5L — literal entero (no requiere conversión)
  • 1:n — siempre produce enteros
x <- 7.8
cat('as.integer(7.8):', as.integer(x), '
')  # 7 (truncate)
cat('round(7.8):     ', round(x), '
')       # 8
cat('floor(7.8):     ', floor(x), '
')       # 7
cat('ceiling(7.8):   ', ceiling(x), '
')     # 8

Comprobación rápida

¿Qué devuelve as.integer(3.9) en R?

Recapitulación: conversión de tipos numéricos

¡Excelente! Estas son las ideas clave de la lección:

  • R tiene dos tipos numéricos: integer (sufijo L, 4 bytes) y double (predeterminado, 8 bytes)
  • as.integer(x) trunca hacia cero, no redondea
  • as.double() y as.numeric() son idénticas: convierten a double
  • / siempre devuelve double, incluso con operandos enteros
  • 1:n crea secuencias de enteros; los literales numéricos sin L son double
  • El desbordamiento de enteros se produce alrededor de los 2.1 mil millones → utilice double para números enteros muy grandes
# Demonstrate truncation vs rounding
test_vals <- c(0.1, 0.5, 0.9, 1.5, 2.5, 3.7)
cat('Values:      ', test_vals, '
')
cat('as.integer(): ', as.integer(test_vals), '
')  # truncation
cat('round():      ', round(test_vals), '
')       # nearest (banker)

Preguntas frecuentes

¿La lección «Conversión entre tipos numéricos» es gratis?

Sí — el texto completo de «Conversión entre tipos numéricos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de R Academy, actualiza a CoddyKit PRO. El curso de R Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Conversión entre tipos numéricos»?

Use as.integer(), as.double() y as.numeric() de forma segura. Practicas R Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar R Academy?

No se requiere experiencia previa. R Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Conversión entre tipos numéricos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de R Academy?

Sí. Cada lección de R Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Descripción general del sistema de tipos de R
  2. Conversión entre tipos numéricos
  3. Conversión de tipos logical y character
  4. Problemas y buenas prácticas de coerción
← Volver a R Academy