Funciones

Si te encontrás una y otra vez copiando la misma linea de código para realizar una operación entonces es hora de escribir una función que haga esa tarea por vos. Hasta ahora estuvimos utilizando funciones que vienen con R (lo que llamamos R base) y funciones de librerías que están disponibles para extender las funcionalidades de R. Ahora vamos a ver como definir funciones propias.

Esta función será un conjunto de comandos o líneas de código que podrá ser definida para usarla en el futuro, con un nombre (con suerte uno que represente la acción u operación para la cual la estamos creando), elementos de entrada y el resultado final.

Vamos a definir la primera función para convertir viento en nudos a viento en metros por segundo que vamos a llamar nudos_a_ms().

nudos_a_ms <- function(viento) {
  ms <- viento * 0.5144
  return(ms)
}

function define nuestra función nudos_a_ms() y al correr esas lineas de código se generará un nuevo elemento en nuestro ambiente, la función está lista para ser usada. Pero antes de probarla revisemos la receta para definir una función.

Ya vimos que necesitamos declarar que esto es una función con function(), luego le sigue el cuerpo de la función, las líneas de código que se ejecutarán, y que van entre llaves {}. Usualmente indentamos el código para que se lea mejor, al igual que pasa cuando escribimos el código para generar un gráfico. Pero estos espacios antes del comienzo de cada renglón no son necesarios para que el código funcione.

La función puede recibir uno o más elementos de entrada: los argumentos. En este caso solo recibe un argumento al que llamamos viento. Al final usamos la función return(), que devolverá un valor o elemento que resulte de los cálculos previos.

Ahora probemos calcular cuantos metros por segundos son 15 nudos usando la función.

nudos_a_ms(viento = 15)

## [1] 7.716

El elemento de entrada en este caso es un número (15) y nos devolvió también un número. Pero podríamos tener un vector de números que corresponden a la velocidad del viento en nudos y que necesitamos convertir a metros por segundos. ¿Cuál crees que será el resultado?

viento_de_ayer <- c(0, 5, 15, 2, 5, 10)

Ahora el elemento de entrada es un vector de números y por lo tanto, la función nos devolverá otro vector aplicando la operación viento * 0.5144 a cada elemento del vector.

nudos_a_ms(viento = viento_de_ayer)

## [1] 0.0000 2.5720 7.7160 1.0288 2.5720 5.1440

Desafío

Escribí una nueva función que se llame ms_a_nudos() que tome el viento en metros por segundos y lo convierta a nudos. Pista: ahora tenés que multiplicar por 1.944.

Funciones con condiciones

Ahora que ya tenemos un par de funciones escritas, es importante asegurarnos de que funcionen de la manera en la que queremos. En este caso esperamos que dado un valor numérico nos devuelva otro valor numérico. ¿Qué pasaría si recibe un caracter?

nudos_a_ms(viento = "fuerte")

## Error in viento * 0.5144: non-numeric argument to binary operator

Por supuesto, nos da error, aunque uno no muy claro. También podríamos querer que la función primero revise si el o los elementos de entrada cumplen con determinadas condiciones, por ejemplo que sea un valor numérico.

nudos_a_ms <- function(viento) {
  stopifnot(is.numeric(viento))  # ¿Es de tipo numérico?
  
  ms <- viento * 0.5144
  return(ms)
}

Ahora si el valor de entrada es “15”, la función falla.

nudos_a_ms(viento = "15")

## Error in nudos_a_ms(viento = "15"): is.numeric(viento) is not TRUE

El error es un poquito más informativo, pero podrías ser mejor! Lo bueno es que podríamos incluir más de una condición, por ejemplo que el valor de entrada viento sea menor a un valor máximo.

Desafío

A tu función ms_a_nudos() agregale alguna condición que debe cumplir el argumento de entrada y ejecutala nuevamente.

Algo importante a tener en cuenta: cualquier variable o elemento que se crea o modifica dentro del cuento de la función solo existe mientras la función se está ejecutando. Por ejemplo la variable ms que creamos adentro de la función nudos_a_ms() solo existe adentro de esa función. Podés revisar el ambiente de R y comprobar que no hay ninguna variable llamada ms aún luego de ejecutar la función nudos_a_ms() varias veces.

Aplicaciones

Hasta ahora definimos funciones que tal vez no tengan mucha aplicación, al ejecutar estas funciones tampoco guardamos el resultado en una nueva variable porque estábamos probando como funcionaban. Ahora vamos a ver como incorporar todo lo anterior a nuestro flujo de análisis.

Vamos a seguir trabajando con diamantes y el objetivo final será generar una nueva columna que contenga el volumen de cada uno de los diamantes en esa base de datos. Cómo te imaginarás vamos a usar la función mutate() para crear esta nueva columna.

library(datos)
library(dplyr)

diamantes %>% 
  mutate(volumen = x * y * z) # El volumen se calcula como ancho x alto x largo asumiendo que es un cubo

## # A tibble: 53,940 x 11
##    precio quilate corte color claridad profundidad tabla     x     y     z
##     <int>   <dbl> <ord> <ord> <ord>          <dbl> <dbl> <dbl> <dbl> <dbl>
##  1    326   0.23  Ideal E     SI2             61.5    55  3.95  3.98  2.43
##  2    326   0.21  Prem… E     SI1             59.8    61  3.89  3.84  2.31
##  3    327   0.23  Bueno E     VS1             56.9    65  4.05  4.07  2.31
##  4    334   0.290 Prem… I     VS2             62.4    58  4.2   4.23  2.63
##  5    335   0.31  Bueno J     SI2             63.3    58  4.34  4.35  2.75
##  6    336   0.24  Muy … J     VVS2            62.8    57  3.94  3.96  2.48
##  7    336   0.24  Muy … I     VVS1            62.3    57  3.95  3.98  2.47
##  8    337   0.26  Muy … H     SI1             61.9    55  4.07  4.11  2.53
##  9    337   0.22  Regu… E     VS2             65.1    61  3.87  3.78  2.49
## 10    338   0.23  Muy … H     VS1             59.4    61  4     4.05  2.39
## # … with 53,930 more rows, and 1 more variable: volumen <dbl>

El cálculo del volumen es bastante directo y en principio no parece ser necesario escribir una nueva función para hacer esto. Sin embargo, si vamos a hacer esto muchas veces, tal vez sea conveniente definir una función volumen() que haga el cálculo. Al mismo tiempo el código es mucho más claro!

Definamos esta función que ahora requiere 3 argumentos:

volumen <- function(ancho, alto, largo) {
  stopifnot(is.numeric(ancho), is.numeric(alto), is.numeric(largo))
  
  total <- ancho * alto * largo
  return(total)
}

Ahora con nuestra función definida podemos calcular el volumen:

diamantes %>% 
  mutate(volumen = volumen(x, y, z))

## # A tibble: 53,940 x 11
##    precio quilate corte color claridad profundidad tabla     x     y     z
##     <int>   <dbl> <ord> <ord> <ord>          <dbl> <dbl> <dbl> <dbl> <dbl>
##  1    326   0.23  Ideal E     SI2             61.5    55  3.95  3.98  2.43
##  2    326   0.21  Prem… E     SI1             59.8    61  3.89  3.84  2.31
##  3    327   0.23  Bueno E     VS1             56.9    65  4.05  4.07  2.31
##  4    334   0.290 Prem… I     VS2             62.4    58  4.2   4.23  2.63
##  5    335   0.31  Bueno J     SI2             63.3    58  4.34  4.35  2.75
##  6    336   0.24  Muy … J     VVS2            62.8    57  3.94  3.96  2.48
##  7    336   0.24  Muy … I     VVS1            62.3    57  3.95  3.98  2.47
##  8    337   0.26  Muy … H     SI1             61.9    55  4.07  4.11  2.53
##  9    337   0.22  Regu… E     VS2             65.1    61  3.87  3.78  2.49
## 10    338   0.23  Muy … H     VS1             59.4    61  4     4.05  2.39
## # … with 53,930 more rows, and 1 more variable: volumen <dbl>

Y tal vez necesitemos el volumen promedio para algún tipo de corte.

diamantes %>% 
  mutate(volumen = volumen(x, y, z)) %>% 
  filter(corte == "Ideal") %>% 
  summarise(volumen_promedio = mean(volumen))

## # A tibble: 1 x 1
##   volumen_promedio
##              <dbl>
## 1             115.

Como siempre en R, hay muchas maneras de resolver cada problema. Otra posible opción sería definir una función que en un solo paso nos devuelva el volumen promedio de los diamantes de algún corte en particular.

volumen_promedio <- function(datos, este_corte) {
  datos %>% 
    filter(corte == este_corte) %>% 
    summarise(volumen_promedio = mean(x * y * z)) 
}

volumen_promedio(diamantes, "Ideal")

## # A tibble: 1 x 1
##   volumen_promedio
##              <dbl>
## 1             115.

Ahora la nueva función volumen_promedio() requiere 2 argumentos, el data.frame con los datos y una cadena de caracteres indicando el tipo de corte. Es posible que hayas notado que no incluimos la función return(), esto es porque R devuelve el último elemento que se generó, en este caso el resultado final de esa cadena de comandos y que coincide con la salida que esperamos.

Desafío

Al igual que vimos en las funciones de R base o por ejemplo de tidyverse, los argumentos de las funciones definidas por nosotros, también pueden tener valores por defecto. Esto quiere decir que podríamos querer que la función volumen_promedio() calcule el volumen promedio para el corte “Regular” a menos que le indiquemos otra cosa.

El valor por defecto de un argumento debe ser definido al momento de crear la función. Probá cambiar corte por corte = "Regular" como argumento de la función volumen_promedio() y ejecutala nuevamente indicando y omitiendo el tipo de corte en distintos casos.

Documentación y organización

Nombrar funciones (y cualquier otro elemento) es todo un desafío, necesitamos que se informativo pero al mismo tiempo corto y simple de escribir. Por ahora estuvimos haciendo un trabajo aproximadamente aceptable pero si volvemos a revisar estas funciones dentro de un mes o dentro de un año tal vez no recordemos exactamente como funciona una función que creamos. Tal vez imaginemos que va a calcular el volumen, ¿pero los elementos de entrada serán vectores o un data.frame? ¿Que tipo de elemento devuelve?

Por esa razón nunca está de más documentar la función, es decir, describir para que funciona, que elementos requiere, que es lo que devuelve y por que no, un ejemplo. No necesitamos generar una documentación tan detallada como la que encontramos en la ayuda de cada función de dplyr, pero es bueno tener cierto orden.

Y a medida que ganemos práctica y experiencia programando, el abanico de funciones propias que simplifican el trabajo van a ir creciendo. Y si bien podemos copiarlas y pegarlas una y otra vez en cada archivo que usemos y en cada análisis que generemos, esto puede ser trabajoso y las múltiples copias de la misma función ponen en riesgo que nuestro trabajo sea reproducible.

Existe una alternativa mucho más ordenada, es posible guardar todas las funciones en un único archivo de texto o script de R y cargar esas funciones al comienzo del análisis de la misma manera que cargamos los paquetes. Pero a diferencia de los paquetes que se cargan con library(), un script se carga con la función source().

Desafío

1. Generá un nuevo archivo que se llame funciones_utiles.R. Podés hacerlo desde el menú File → New File → R Script o con el atajo Ctrl + Shift + N
2. Copiá las funciones volumen() y volumen_promedio() y agregá una breve descripción junto a cada una usando comentarios (la línea debe comenzar con #).
3. Guardá el archivo dentro de la carpeta del proyecto.
4. En el archivo .Rmd donde venís trabajando, agregá una línea en el primer bloque de código para cargar estas funciones source("funciones_utiles.R").