Tipos de datos en R

En esta entrada veremos a detalle los tipos de datos en R. ¿Cuáles son? ¿cómo usarlos? y ¿cómo manipularlos?

En concreto revisaremos los tipos de datos que hemos visto en entradas pasadas (númerico, lógico y carácter), y profundizaremos entre las clases de valores númericos ("integer" y "double") y los números complejos ("complex"). Vamos allá.

Valores lógicos ("logical")

Este tipo de dato se refiere a los valores booleanos TRUE y FALSE. Se usan en R para saber si alguna condición es verdadera o falsa. Definamos y comparemos algunas variables:

a <- 10
b <- 5

a > b
a == b
a < b

Cuando la comparación es verdadera, la salida es el valor lógico TRUE, de lo contrario la salida es el valor lógico FALSE.

[1] TRUE
[1] FALSE
[1] FALSE

Si guardáramos una de las comparaciones en una variable, estaríamos guardando el valor lógico que le corresponde, y así podríamos ver el tipo de dato con las funciones class() y typeof()

c <- a > b
c

class(c)
typeof(c)

[1] TRUE
[1] "logical"
[1] "logical"

Cabe mencionar, que el valor conocido como NA (Not Available), usado para representar datos faltantes, es decir, datos que no se tienen (como celdas vacías de una hoja de cálculo), es un valor lógico. No es muy útil saberlo pero es así como lo trata R:

x <- NA
class(x)
typeof(x)

[1] "logical"
[1] "logical"

Valores carácter ("character")

Estos valores se usan para representar texto. Todo lo que escribas entre comillas dobles ("") o comillas simples(''), aunque pueda parecer valor lógico o numérico, R lo interpretará como valor carácter:

x <- "TRUE"
y <- '10'

class(x)
typeof(x)
class(y)
typeof(y)

[1] "character"
[1] "character"
[1] "character"
[1] "character"

Importante
Ya sea que uses comillas dobles o simples, éstas delimitan tu valor carácter. No puedes usar comillas dobles dentro de comillas dobles, ni comillas simples dentro de comillas simples.

Si quieres usar comillas dobles dentro de un valor carácter, tienes que delimitarlo con comillas simples. De igual forma, si quieres usar comillas simples dentro de tu texto, tiene que delimitarlo con comillas dobles:

z <- 'comillas dobles "dentro"'
w <- "comillas simples 'dentro'"

z
w

Si colocas comillas dobles dentro de comillas simples, R las define usando un carácter especial antes de ellas (\"). Si usas comillas simples dentro de dobles no hay tanto problema.

[1] "comillas dobles \"dentro\""
[1] "comillas simples 'dentro'"

Valores numéricos ("numeric")

Dentro del tipo de dato numérico se incluyen los números reales. Aunque los definas sin decimales, R los interpreta como "double precision floating number", es decir, número con al menos dos decimales. Veamos ejemplos:

a <- -999
b <- 3.1416

#Usemos notación científica
c <- 2.1e-4
d <- 5e10

class(a)
typeof(a)
class(b)
typeof(b)
class(c)
typeof(c)
class(d)
typeof(d)

[1] "numeric"
[1] "double"
[1] "numeric"
[1] "double"
[1] "numeric"
[1] "double"
[1] "numeric"
[1] "double"

También cabe mencionar que R interpreta como datos numéricos de tipo "double" los valores Inf, -Inf y NaN. Los primeros se refieren al infinito positivo y negativo, mientras que NaN significa "Not A Number", y es el resultado, por ejemplo, de 0/0.

x <- Inf
y <- NaN

class(x)
typeof(x)
class(y)
typeof(y)

[1] "numeric"
[1] "double"
[1] "numeric"
[1] "double"

Valores enteros ("integer")

R normalmente hace las conversiones entre valores numéricos y valores enteros, pero cuando estás seguro que sólo vas a manejar números enteros, puedes definirlos con una L, de la siguiente manera:

a <- 3L
class(a)
typeof(a)

#Si intentas definir un entero con decimal (a <- 3.5L) R lo interpretará como numérico "double"

[1] "integer"
[1] "integer"

Valores complejos ("complex")

Si trabajas mucho con números complejos, R los implementa de una manera fácil e intuitiva. Los puedes definir de la siguiente manera:

x <- 3i
y <- 4+1i

x
y
class(x)
typeof(y)

[1] 0+3i
[1] 4+1i
[1] "complex"
[1] "complex"

Manipulación y conversión

Si necesitas saber si tu valor es lógico, puedes usar la función is.logical(). De la misma forma, tenemos is.character(), is.numeric(), is.integer() y por último is.complex. La salida será TRUE si tu valor es en efecto lo que preguntaste, y FALSE si no lo es. Ejemplos:

is.logical(TRUE)
is.character("TRUE")
is.numeric(3.5)
is.integer(NaN)
is.complex(x)

[1] TRUE
[1] TRUE
[1] TRUE
[1] FALSE
[1] TRUE

Por otro lado, si necesitas convertir un tipo de dato en otro se usan las funciones: as.logical(), as.character(), as.numeric(), as.integer() y as.complex.

Importante
No todas las conversiones son posibles. Por ejemplo, es imposible convertir valores complejos en numéricos.

Veamos algunas de las conversiones que sí son posibles:

as.numeric(TRUE)
as.numeric(FALSE)
as.numeric("30")

as.character(TRUE)
as.character(4+1i)
as.character(30)

as.logical(30)
as.logical(1)
as.logical(0)

as.integer(9.99)

[1] 1
[1] 0
[1] 30
[1] "TRUE"
[1] "4+1i"
[1] "30"
[1] TRUE
[1] TRUE
[1] FALSE
[1] 9

Comentarios finales

Hasta aquí llegamos por hoy. Los tipos de datos son un concepto básico para programar en R pero dominarlos nos permite aumentar nuestra eficiencia al resolver problemas y crear herramientas.

Si el blog te está ayudando a aprender, por favor compártelo con tus compañeros y amigos.

Eso es todo, ¡gracias por leer!