tibble.qmd

---
title: "[tibble](https://tibble.tidyverse.org/)"
toc: true
toc-depth: 4
format:
  gfm: default
  html:
    css: ecosistemas.css
knitr:
  opts_chunk: 
    echo: true
    eval: true
    error: true
    collapse: true
    comment: "#>" 
editor: visual
editor_options: 
  chunk_output_type: console
---

> Un tibble, o tbl_df, es una reestructuración moderna del data.frame, manteniendo lo que ha demostrado ser eficaz a lo largo del tiempo y desechando lo que no lo ha sido.

```{r libreria}
# install.packages("tibble")
library(tibble)

# o directamente
library(tidyverse)
```

## tibble vs data frame

Este documento está basado en <https://tibble.tidyverse.org/articles/tibble.html>

#### Creación

Nunca cambia el tipo de input.

```{r tipo de input}
# dataframe a veces cambia strings (cadenas de caracteres) a factores
str(data.frame(
  a = 1:length(letters), 
  b = letters
  # stringsAsFactors = FALSE
  ))

# tibble nunca
tibble(
  a = 1:length(letters), 
  b = letters
  )
```

Permite trabajar con listas-columna.

```{r listas-columna}
# data frame no permite
data.frame(x = 1:2, y = list(1:3, letters))

# tibble sí
tibble(x = 1:2, y = list(1:3, letters))
```

No ajusta nombres de variables.

```{r nombre de variables}
# data frame elimina los espacios
# y no admite caracteres especiales
names(data.frame(`pred^ocs uah` = 1))

# tibble sí
names(tibble(`pred^ocs uah` = 1))
```

Evalúa los argumentos de forma lazy y secuencial.

```{r evaluacion}
# evaluacion lazy: solo se evalua cuando se requiere el argumento
mult <- function(x, y){
  x * 10
}
mult(5)

# evaluacion secuencial
# data frame no evalua de forma secuencial
data.frame(x = 1:5, y = x * 5)

# tibble si
tibble(x = 1:5, y = x * 5)
```

#### Impresión

La funcion `print()` muestra solamente las 10 primeras filas por defecto y todas las columnas que caben en la pantalla. Indica el tipo de cada columna y utiliza distintos estilos de fuente y colores para destacar aspectos importantes que faciliten la interpretación del output.

```{r impresion}
# n. de filas (todas las columnas)
# n. de columnas (ampliar y disminuir el tamano de la consola)
# tipo de variable (todas las columnas)
# colorea valores positivos y negativos (col x)
# los miles estan subrayados (col y)
# se muestran los tres digitos mas importantes de cada numero (es decir los digitos que representan > 99.9% del valor del numero) y un punto final que indica la existencia de decimales (col z y h)

data.frame(
  x = -5:5,
  y = 1000:1010,
  z = pi * 300
  )

tibble(
  x = -5:5,
  y = 1000:1010,
  z = pi * 300,
  h = pi * x ^ x,
  k = x
  )
```

Se pueden modificar las opciones por defecto.

```{r modificar opciones de impresion}
# p.ej. para mostrar siempre todas las filas
options(pillar.print_max = Inf)

# p.ej. para mostrar siempre todas las columnas
options(pillar.width = Inf)
```

#### Subconjuntos (subset)

Al realizar un subset a un tibble \[\] siempre devuelve otro tibble. Sin embargo, en data frames a veces devuelve un data frame y otras, un vector.

```{r subconjuntos}
df <- data.frame(x = 1:5, y = 6:10)
# data frame
class(df[, 1:2])
# vector
class(df[, 1])

tbl <- tibble(x = 1:5, y = 6:10)
# tibble
class(tbl[, 1:2])
# tibble
class(tbl[, 1])

# se puede extraer una sola columna en un tibble mediante [[]] y $
class(tbl[[1]])
class(tbl$x)
```

Los tibbles son mas restrictivos con el operador \$. Nunca realizan coincidencias parciales, y lanzan una advertencia y devuelven NULL si la columna no existe.

```{r coincidencias parciales}
df <- data.frame(hello = 1)
df$h
df$he
df$hel
df$hell
df$hello

tbl <- tibble(hello = 1)
tbl$h
tbl$he
tbl$hel
tbl$hell
tbl$hello
```

Los tibbles no admiten nombres de fila. Estos se eliminan al convertir desde data frame a tibble o al realizar un subset.

```{r nombres de fila}
df <- data.frame(x = 1:5, row.names = letters[1:5])
rownames(df)

# se eliminan
rownames(as_tibble(df))

tbl <- tibble(x = 1:5)
# advertencia
rownames(tbl) <- letters[1:5]
# existen
rownames(tbl)
# pero al realizar el subset se eliminan
rownames(tbl[5, ])
```

#### Reciclaje

Al construir un tibble, sólo se reciclan los valores de longitud 1. La primera columna con longitud diferente a uno determina el número de filas del tibble.

```{r reciclaje}
# longitud de 1 -> se recicla
data.frame(x = 1, y = 1:6)
tibble(x = 1, y = 1:6)

# longitud de 2 -> se recicla
data.frame(x = 1:2, y = 1:6)
# longitud de 2 -> no se recicla
tibble(x = 1:2, y = 1:6)
```

#### Operaciones aritméticas

Los tibbles no admiten operaciones aritméticas en las columnas y por ello lo convierten silenciosamente a un data frame en el momento de realizar las operaciones. Indican que esto se puede convertir en un error en una próxima versión de tibble.

```{r operaciones aritmeticas}
df <- data.frame(a = 1:5, b = 6:10)
class(df * 2)

tbl <- tibble(a = 1:5, b = 6:10)
class(tbl * 2)
```

#### Coerción

Tibble proporciona la función `as_tibble()` para coercionar objetos hacia tibbles. Sus métodos son más sencillos y por tanto, más rápidos que los de `as.data.frame()`.

```{r coercion}
x <- replicate(10, sample(100), simplify = FALSE)
names(x) <- letters[1:length(x)]

timing <- bench::mark(
  as_tibble(x),
  as.data.frame(x),
  check = FALSE,
  time_unit = "ns"
)

timing
```

Tidyverse está optimizado para usar tibbles!