Funciones

Fecha de publicación

12 de noviembre de 2023

Objetivo del manual

Identificar los elementos básicos que componen una función
Comprender las características de los principales tipos de argumentos en las funciones
Ser capaz de construir funciones propias

1 Funciones en R

Todo lo que sucede en R es una llamada de una función (i.e. las manipulaciones y cálculos de objetos en R se realizan a través de una función)
Una función es una subrutina que tiene como objetivo realizar una tarea específica
Permite a los usuarios juntar bloques de código que se usan con frecuencia y, por lo tanto, resulta conveniente encapsular en un objeto que se puede llamar fácilmente cuando sea necesario
Las funciones cargadas desde los paquetes (incluido R básico) también se pueden modificar y sobrescribir

2 Estructura básica

Todas las funciones son creadas iguales … mediante la función function() y siguen la misma estructura:

* Modificado de Wickham et al. 2016

Podemos observar la estructura de funciones ya cargadas en nuestro entorno de R. Para ver el código simplemente corra al nombre de la función en R (sin el paréntesis). Por ejemplo, el código de la función sd() se puede mostrar de la siguiente manera:

Código

sd

function (x, na.rm = FALSE) 
sqrt(var(if (is.vector(x) || is.factor(x)) x else as.double(x), 
    na.rm = na.rm))
<bytecode: 0x562bff19b548>
<environment: namespace:stats>

En Rstudio, el código también se puede mostrar usando F2 cuando el cursor está en el nombre de la función.

Además, podemos diseccionar las funciones en sus elementos básicos:

Código

# cuerpo
body(sd)

sqrt(var(if (is.vector(x) || is.factor(x)) x else as.double(x), 
    na.rm = na.rm))

Código

# argumentos
formals(sd)

$x


$na.rm
[1] FALSE

Código

# ambiente
environment(sd)

<environment: namespace:stats>

Algunas funciones R utilizan funciones primitivas (principalmente escritas en C). En estos casos, el código no se muestra:

Código

sum

function (..., na.rm = FALSE)  .Primitive("sum")

Código

body(sum)

NULL

Código

formals(sum)

NULL

Código

environment(sum)

NULL

Las funciones son en sí mismas un tipo específico de objeto:

Código

class(sd)

[1] "function"

Los operadores son funciones:

Código

1 + 1

[1] 2

Código

"+"(1, 1)

[1] 2

Código

2 * 3

[1] 6

Código

"*"(2, 3)

[1] 6

2.1 Nombre

Los nombres de las funciones tienen pocas restricciones. Siguen las mismas reglas que otros objetos en R. Algunas recomendaciones/reglas:

No utilice nombres de objetos comunes R (por ejemplo, iris, x) u objetos que ya están en el entorno
No use nombres de funciones de uso frecuente (por ejemplo, mean)
No puede comenzar con un número
Debería sugerir lo que hace
No debe ser muy largo

En caso de que tenga varias funciones con el mismo nombre, puede llamarlas individualmente utilizando el nombre del paquete (o namespace) seguido de :::

Código

# crear funcion sd
sd <- function(x) x^10

# no calcula desv. st.
sd(1:5)

[1]       1    1024   59049 1048576 9765625

Código

# sd
stats::sd(1:5)

[1] 1.5811

Código

# remover nueva sd
rm(sd)

# usar de nuevo
sd(1:5)

[1] 1.5811

La sintaxis namespace::function también se puede usar para llamar a funciones desde paquetes que se han instalado pero que no están cargados en el entorno actual.

Las funciones pueden ser anónimas:

Código

(function(x) x^10)(1:5)

[1]       1    1024   59049 1048576 9765625

Esto es más útil cuando se usan las funciones Xapply:

Código

l <- list(1:5, 1:4, 1:3)

lapply(l, function(x) x^10)

[[1]]
[1]       1    1024   59049 1048576 9765625

[[2]]
[1]       1    1024   59049 1048576

[[3]]
[1]     1  1024 59049

2.2 Argumentos

Permiten a los usuarios ingresar objetos en la función. Los argumentos pueden o no tener valores predeterminados. Cuando los argumentos tienen valores predeterminados, no es necesario proporcionarlos:

Código

f1 <- function(x, y = 2) x + y

f1(1)

[1] 3

Por supuesto, se pueden modificar:

Código

f1(3, 4)

[1] 7

Los argumentos sin valor predeterminado deben ser proporcionados:

Código

f1()

Error in f1(): el argumento "x" está ausente, sin valor por omisión

Si todos los argumentos tienen un valor predeterminado, se puede invocar la función sin proporcionar ningún argumento:

Código

f1 <- function(x = -2, y = 2) x + y

f1()

[1] 0

Ese es el caso de dev.off() y Sys.time():

Código

Sys.time()

[1] "2023-11-12 14:03:53.503 CST"

Los argumentos pueden especificarse implícitamente por posición o por nombres incompletos:

Código

f2 <- function(a1, b1, b2) {
  list(a1 = a1, b1 = b1, b2 = b2)
}

# por posicion
str(f2(1, 2, 3))

List of 3
 $ a1: num 1
 $ b1: num 2
 $ b2: num 3

Código

# por posicion y nombre
str(f2(a = 1, 2, 3))

List of 3
 $ a1: num 1
 $ b1: num 2
 $ b2: num 3

Código

str(f2(1, a = 2, 3))

List of 3
 $ a1: num 2
 $ b1: num 1
 $ b2: num 3

Código

str(f2(1, 2, a = 3))

List of 3
 $ a1: num 3
 $ b1: num 1
 $ b2: num 2

Código

# por posicion y nombre parcial
str(f2(1, a = 2, b1 = 3))

List of 3
 $ a1: num 2
 $ b1: num 3
 $ b2: num 1

Sin embargo, esto no funciona si los nombres son ambiguos:

Código

f2(b = 1, 2, a = 3)

Error in f2(b = 1, 2, a = 3): el argumento 1 concuerda con multiples argumentos formales

Es más seguro (y, por lo tanto, una mejor práctica) usar los nombres completos de los argumentos.

Las funciones también pueden tomar argumentos lógicos. Estos son útiles para modificar el comportamiento de la función para que coincida con diferentes escenarios. Por ejemplo, mean() permite a los usuarios ignorar los NA:

Código

v1 <- c(1, 2, 3, NA)

# sin ignorar NAs
mean(v1, na.rm = FALSE)

[1] NA

Código

# ignorando NAs
mean(v1, na.rm = TRUE)

[1] 2

2.3 Ejercicio 1

1.1 ¿Qué hace la función cor.test()?

1.2 Úsela con “Sepal.Length” y “Sepal.Width” de los datos de ejemplo iris (use data(iris))

1.3 ¿Qué argumentos deben proporcionarse?

1.4 ¿Qué hace el argumento alternative? Use diferentes valores para este argumento y compare los resultados

1.5 ¿Cómo se puede calcular la correlación de Spearman?

1.6 ¿Qué tipo de objeto devuelve esta función?

1.7 ¿Cómo puede obtener el valor de p directamente del resultado de la función (sin guardar el resultado como un objeto)?

1.8 Escoga una función de R y lea su documentación con el fin de entender su uso, cada uno de sus argumentos (y que tipo de objetos requieren) y el resultado que produce (es probable que se le pida que explique esto al grupo)

2.4 Cuerpo

El cuerpo de una función puede contener:

Comprobación de argumentos
Manipulación de datos
Definición de resultados

El cuerpo de la función puede tomar el mismo tipo de código utilizado en cualquier rutina de R. Sin embargo, los objetos creados no estarán disponibles en el entorno.

Cuando se realizan varios cálculos, debemos incluir una declaración de retorno (return statement), que define explícitamente la salida de la función. Esto se hace usando la función return():

Código

# sin "return statement"
f1 <- function(x, y) {
  z1 <- 2 * x + y
  z2 <- x + 2 * y
  z3 <- 2 * x + 2 * y
  z4 <- x / y
}

f1(5, 3)

f1_out <- f1(5, 3)

f1_out

[1] 1.6667

Código

# con "return statement"
f2 <- function(x, y) {
  z1 <- 2 * x + y
  z2 <- x + 2 * y
  z3 <- 2 * x + 2 * y
  z4 <- x / y

  return(c(z1, z2, z3, z4))
}

f2(5, 3)

[1] 13.0000 11.0000 16.0000  1.6667

Código

f2_out <- f2(5, 3)

f2_out

[1] 13.0000 11.0000 16.0000  1.6667

Por lo tanto, cuando no se proporciona una declaración de retorno, la función devolverá el último objeto que se creó en el cuerpo de la función:

Código

# sin "return statement"
f3 <- function(x, y) {
  z1 <- 2 * x + y
  z2 <- x + 2 * y
  z3 <- 2 * x + 2 * y
  z4 <- x / y

  c(z1, z2, z3, z4)
}

f3(5, 3)

[1] 13.0000 11.0000 16.0000  1.6667

Código

f3_out <- f3(5, 3)

f3_out

[1] 13.0000 11.0000 16.0000  1.6667

Es más seguro usar return().

Cuando una función realiza varias tareas, podemos usar una lista para juntar los diferentes objetos. Esto es particularmente útil cuando se generan objetos de diferentes clases (por ejemplo, vectores y listas):

Código

f4 <- function(x, y) {
  # 1 elemento
  z1 <- x + y

  # 2 elementos
  z2 <- c(x, y / 3)

  # vector logico
  z3 <- z2 < 10


  l <- list(z1, z2, z3)

  return(l)
}

f4(10, 5)

[[1]]
[1] 15

[[2]]
[1] 10.0000  1.6667

[[3]]
[1] FALSE  TRUE

Podemos acceder a elementos específicos de la salida de una función mediante indexación:

Código

# elemento 1
f4(10, 5)[[1]]

[1] 15

Código

# elemento 2
f4(10, 5)[[2]]

[1] 10.0000  1.6667

Código

# elemento 3
f4(10, 5)[[3]]

[1] FALSE  TRUE

Por supuesto, también podemos guardar el resultado como un objeto y acceder a cada elemento mediante la indexación:

Código

# elemento 1
out <- f4(10, 5)

# elemento 1
out[[1]]

[1] 15

Código

# elemento 2
out[[2]]

[1] 10.0000  1.6667

2.5 Ejercicio 2

2.1 Cree una función llamada promedio que calcule el promedio de un vector numérico. Internamente solo puede utilizar las funciones sum() y length() (suma y división, no puede llamar la función mean())

2.2 Cree una función que tome 2 argumentos numéricos (llámelos ‘x’ y ‘y’), eleve cada uno al cuadrado y luego los sume

2.3 Agregue valores predeterminados a cada argumento

2.4 Ejecute la función usando los valores predeterminados

2.5 Ejecute la función usando un valor predeterminado y uno proporcionado en la llamada

2.6 Ejecute la función proporcionando ambos valores en la llamada

3 Argumentos lógicos

Son argumentos que pueden tomar solo dos valores: TRUE o FALSE. Estos argumentos permiten modificar el comportamiento de la función de forma binaria: si es TRUE llevaría a cabo la tarea 1 y si es FALSE llevaría a cabo la tarea 2. Internamente (i.e. en el cuerpo de las función) estas funciones implican el uso del operador if, algunas veces incluyendo su contra-parte else. Estos operadores son parte fundamental de la programación y se usan para definir que acción ejecutar con base en una evaluación lógica:

Código

# creemos el objeto a con valor 2
a <- 2

# elevemos a la 2 si a es mayor q 0
if (a > 0) {
  a^2
}

[1] 4

Código

# elevemos a la 2 si a es mayor q 0 de lo contrario elevemoslo a la 100
if (a > 0) {
  a^2
} else {
  a^100
}

[1] 4

Código

# con a negativo
a <- -3
if (a > 0) {
  a^2
} else {
  a^3
}

[1] -27

La parte dentro de los paréntesis justo después de if es la evaluación lógica.

Estos operadores son utilizados en el cuerpo de la función cuando esta lleva un argumento lógico. Por ejemplo, la siguiente función utiliza un argumento lógico para decidir si la operación algebraica a realizar es una suma o un promedio:

Código

mean_sum <- function(x, y, prom = FALSE) {
  if (prom) {
    b <- mean(c(x, y))
  } else {
    b <- sum(c(x, y))
  }

  return(b)
}

Note que este tipo de argumentos deben tener un valor predeterminado. Podemos probar la función de la siguiente forma:

Código

mean_sum(x = 2, y = 3)

[1] 5

3.1 Ejercicio 3

3.1 Cree una función que tome 3 argumentos numéricos, multiplíquelos y luego calcule el logaritmo natural del resultado (función log())

3.2 Agregue valores predeterminados a cada argumento

3.3 Ejecute la función con uno de los argumentos con un número negativo. ¿Qué pasa? ¿Por qué?

3.4 Agregue un argumento lógico que permita a los usuarios (si lo desean) convertir los argumentos de entrada a su valor absoluto (usando la función abs()). Agregue las modificaciones necesarias para que la función haga los cálculos con y sin valores absolutos.

4 Ventajas de usar funciones

4.1 Código mas limpio

Los objetos creados dentro del cuerpo no están disponibles en el entorno actual:

Código

# primero remover todo los objetos
rm(list = ls())

f5 <- function(x) {
  sqr <- x * x
  lg_sqr <- log(x)
  return(lg_sqr)
}

f5(7)

[1] 1.9459

Código

exists("sqr")

[1] FALSE

Código

exists("lg_sqr")

[1] FALSE

Código

x <- 7
sqr <- x * x
lg_sqr <- log(x)


exists("sqr")

[1] TRUE

Código

exists("lg_sqr")

[1] TRUE

4.2 Facil de correr y compartir

Se pueden invocar funciones desde archivos de R externos sin estar definidas en el código actual con la función source(). En este ejemplo creamos la función fnctn_X:

Código

fnctn_X <- function(sq_mt, vctr) {
  # trasponer matriz y calcular est dev
  stp1 <- t(sq_mt)
  stp2 <- vctr * vctr

  # guardar en lista
  rslt <- list(stp1, stp2)
  return(rslt)
}

fnctn_X(sq_mt = cbind(c(1, 2), c(3, 4)), vctr = c(2, 3))

[[1]]
     [,1] [,2]
[1,]    1    2
[2,]    3    4

[[2]]
[1] 4 9

Guarde el código anterior en un archivo R llamado ‘function_X.R’. Ahora la función se puede cargar usando source():

Código

# removamosla del ambiente
rm(fnctn_X)

# cargar funcion
source("function_X.R")

# run it
fnctn_X(sq_mt = cbind(c(1, 2), c(3, 4)), vctr = c(2, 3))

[[1]]
     [,1] [,2]
[1,]    1    2
[2,]    3    4

[[2]]
[1] 4 9

Además, este código se puede compartir fácilmente. Se puede enviar por correo electrónico o publicar en línea. Incluso se puede cargar desde repositorios en línea:

Código

# remover objetos
rm(list = ls())

# revisar si existe en ambiente actual
exists("fnctn_X")

[1] FALSE

Código

# cargar desde el internet
source(
  paste0(
    "https://raw.githubusercontent.com/maRce10/",
    "r_avanzado_2023/master/data/function_x.r"
  )
)


# revisar si existe en ambiente actual
exists("fnctn_X")

[1] TRUE

4.3 Se aplica fácilmente a nuevos objetos

Esto ya debería ser obvio a este punto.

4.4 Otros consejos

Construir funciones cortas:
- Fácil de leer
- Fácil de arreglar y actualizar
- Si es demasiado largo, probablemente debería dividirse en varias funciones
- Genera modularidad
Añadir comentarios a todo el código
Agregar descripciones a cada uno de los argumentos que toma
Función de prueba con diferentes valores/escenarios

4.5 Ejercicio 4

4.1 Cree una funcion que calcule el promedio, la desviación estándar y el error estándar de un vector numérico. Estos valores deben ser devueltos como una lista con nombres.

4.2 Permita a los usuarios ignorar los NAs (similar al argumento na.rm en mean(), pista: añada un argumento lógico)

4.3 Haga que la función además produzca un histograma del vector numérico proporcionado por el usuario

4.4 Haga que la función escoja un color al azar para las barras del histograma cada vez que se corre (pista: sample(vector.de.colores, 1))

4.5 Añada un argumento a la función que permita el usuario, si lo desea, calcular la sumatoria (sum()) junto con el resto de los descriptores estadísticos

4.6 Agregue el promedio y la desviación estándar al título del histograma (pista: use paste())

4.7 Modifique la función para que también cree una linea vertical indicando el promedio del vector numérico proporcionado por el usuario

4.8 Modifique la función para que añada un polígono transparente sobre el área que cubre el promedio +/- la desviación estándar (puede usar la función rect())

4.9 Modifique la función con un argumento lógico que permita al usuario controlar si se crea un gráfico o no

4.6 Lecturas adicionales

Introduction to R guide to writing functions with information for a total beginner
Information on functions for intermediate and advanced users (Hadley Wickham).
The official R intro material on writing your own functions (ir a “Writing your own function”)

4.7 Referencias

Wickham, Hadley, and Garrett Grolemund. 2016. R for data science: import, tidy, transform, visualize, and model data. website

Información de la sesión

R version 4.1.2 (2021-11-01)
Platform: x86_64-pc-linux-gnu (64-bit)
Running under: Ubuntu 22.04.2 LTS

Matrix products: default
BLAS:   /usr/lib/x86_64-linux-gnu/blas/libblas.so.3.10.0
LAPACK: /usr/lib/x86_64-linux-gnu/lapack/liblapack.so.3.10.0

locale:
 [1] LC_CTYPE=es_CR.UTF-8       LC_NUMERIC=C              
 [3] LC_TIME=es_CR.UTF-8        LC_COLLATE=es_CR.UTF-8    
 [5] LC_MONETARY=es_CR.UTF-8    LC_MESSAGES=es_CR.UTF-8   
 [7] LC_PAPER=es_CR.UTF-8       LC_NAME=C                 
 [9] LC_ADDRESS=C               LC_TELEPHONE=C            
[11] LC_MEASUREMENT=es_CR.UTF-8 LC_IDENTIFICATION=C       

attached base packages:
[1] stats     graphics  grDevices utils     datasets  methods   base     

loaded via a namespace (and not attached):
 [1] htmlwidgets_1.5.4 compiler_4.1.2    fastmap_1.1.1     cli_3.6.1        
 [5] tools_4.1.2       htmltools_0.5.7   rstudioapi_0.13   yaml_2.3.7       
 [9] rmarkdown_2.25    knitr_1.45        jsonlite_1.8.7    xfun_0.41        
[13] digest_0.6.33     rlang_1.1.2       evaluate_0.23

--- title: Funciones toc: true toc-depth: 2 toc-location: left toc-title: Contenidos number-sections: true highlight-style: pygments format: html: theme: simplex css: styles.css toc: true df-print: kable code-fold: show code-tools: true link-external-icon: false link-external-newwindow: true --- ```{=html} <style> body { counter-reset: source-line 0; } pre.numberSource code { counter-reset: none; } </style> ``` ```{r,echo=FALSE,message=FALSE} options("digits" = 5) options("digits.secs" = 3) # options to customize chunk outputs knitr::opts_chunk$set( class.source = "numberLines lineAnchors", # for code line numbers message = FALSE ) ``` ::: {.alert .alert-info} # Objetivo del manual {.unnumbered .unlisted} - Identificar los elementos básicos que componen una función - Comprender las características de los principales tipos de argumentos en las funciones - Ser capaz de construir funciones propias ::: # Funciones en R - Todo lo que sucede en `R` es una llamada de una función (i.e. las manipulaciones y cálculos de objetos en `R` se realizan a través de una función) - Una función es una subrutina que tiene como objetivo realizar una tarea específica - Permite a los usuarios juntar bloques de código que se usan con frecuencia y, por lo tanto, resulta conveniente encapsular en un objeto que se puede llamar fácilmente cuando sea necesario - Las funciones cargadas desde los paquetes (incluido `R` básico) también se pueden modificar y sobrescribir ------------------------------------------------------------------------ # Estructura básica Todas las funciones son creadas iguales ... mediante la función `function()` y siguen la misma estructura: ```{r, echo=FALSE,out.width="100%", fig.align='center'} knitr::include_graphics("./images/funcion.png") ``` \* Modificado de Wickham et al. 2016 Podemos observar la estructura de funciones ya cargadas en nuestro entorno de `R`. Para ver el código simplemente corra al nombre de la función en `R` (sin el paréntesis). Por ejemplo, el código de la función `sd()` se puede mostrar de la siguiente manera: ```{r, eval = T} sd ``` En `Rstudio`, el código también se puede mostrar usando *F2* cuando el cursor está en el nombre de la función. Además, podemos diseccionar las funciones en sus elementos básicos: ```{r} # cuerpo body(sd) # argumentos formals(sd) # ambiente environment(sd) ``` Algunas funciones `R` utilizan funciones primitivas (principalmente escritas en `C`). En estos casos, el código no se muestra: ```{r} sum body(sum) formals(sum) environment(sum) ``` Las funciones son en sí mismas un tipo específico de objeto: ```{r, eval = T} class(sd) ``` Los operadores son funciones: ```{r} 1 + 1 "+"(1, 1) 2 * 3 "*"(2, 3) ``` ------------------------------------------------------------------------ ## Nombre ```{r, echo=FALSE,out.width="100%", fig.align='center'} knitr::include_graphics("./images/nombre.png") ``` Los nombres de las funciones tienen pocas restricciones. Siguen las mismas reglas que otros objetos en `R`. Algunas recomendaciones/reglas: - No utilice nombres de objetos comunes `R` (por ejemplo, *iris*, *x*) u objetos que ya están en el entorno - No use nombres de funciones de uso frecuente (por ejemplo, `mean`) - No puede comenzar con un número - Debería sugerir lo que hace - No debe ser muy largo En caso de que tenga varias funciones con el mismo nombre, puede llamarlas individualmente utilizando el nombre del paquete (o *namespace*) seguido de `::`: ```{r} # crear funcion sd sd <- function(x) x^10 # no calcula desv. st. sd(1:5) # sd stats::sd(1:5) # remover nueva sd rm(sd) # usar de nuevo sd(1:5) ``` La sintaxis `namespace::function` también se puede usar para llamar a funciones desde paquetes que se han instalado pero que no están cargados en el entorno actual. Las funciones pueden ser anónimas: ```{r} (function(x) x^10)(1:5) ``` Esto es más útil cuando se usan las funciones `Xapply`: ```{r} l <- list(1:5, 1:4, 1:3) lapply(l, function(x) x^10) ``` ------------------------------------------------------------------------ ## Argumentos ```{r, echo=FALSE,out.width="100%", fig.align='center'} knitr::include_graphics("./images/argumentos.png") ``` Permiten a los usuarios ingresar objetos en la función. Los argumentos pueden o no tener valores predeterminados. Cuando los argumentos tienen valores predeterminados, no es necesario proporcionarlos: ```{r eval = T} f1 <- function(x, y = 2) x + y f1(1) ``` Por supuesto, se pueden modificar: ```{r eval = T} f1(3, 4) ``` Los argumentos sin valor predeterminado deben ser proporcionados: ```{r error = T} f1() ``` Si todos los argumentos tienen un valor predeterminado, se puede invocar la función sin proporcionar ningún argumento: ```{r eval = T} f1 <- function(x = -2, y = 2) x + y f1() ``` Ese es el caso de `dev.off()` y `Sys.time()`: ```{r eval = T} Sys.time() ``` Los argumentos pueden especificarse implícitamente por posición o por nombres incompletos: ```{r} f2 <- function(a1, b1, b2) { list(a1 = a1, b1 = b1, b2 = b2) } # por posicion str(f2(1, 2, 3)) # por posicion y nombre str(f2(a = 1, 2, 3)) str(f2(1, a = 2, 3)) str(f2(1, 2, a = 3)) # por posicion y nombre parcial str(f2(1, a = 2, b1 = 3)) ``` Sin embargo, esto no funciona si los nombres son ambiguos: ```{r, error=T} f2(b = 1, 2, a = 3) ``` Es más seguro (y, por lo tanto, una mejor práctica) usar los nombres completos de los argumentos. Las funciones también pueden tomar argumentos lógicos. Estos son útiles para modificar el comportamiento de la función para que coincida con diferentes escenarios. Por ejemplo, `mean()` permite a los usuarios ignorar los *NA*: ```{r} v1 <- c(1, 2, 3, NA) # sin ignorar NAs mean(v1, na.rm = FALSE) # ignorando NAs mean(v1, na.rm = TRUE) ``` ::: {.alert .alert-info} ## Ejercicio 1 1.1 ¿Qué hace la función `cor.test()`? 1.2 Úsela con "Sepal.Length" y "Sepal.Width" de los datos de ejemplo *iris* (use `data(iris)`) 1.3 ¿Qué argumentos deben proporcionarse? 1.4 ¿Qué hace el argumento *alternative*? Use diferentes valores para este argumento y compare los resultados 1.5 ¿Cómo se puede calcular la correlación de Spearman? 1.6 ¿Qué tipo de objeto devuelve esta función? 1.7 ¿Cómo puede obtener el valor de **p** directamente del resultado de la función (sin guardar el resultado como un objeto)? 1.8 Escoga una función de R y lea su documentación con el fin de entender su uso, cada uno de sus argumentos (y que tipo de objetos requieren) y el resultado que produce (es probable que se le pida que explique esto al grupo) ::: ------------------------------------------------------------------------ ## Cuerpo ```{r, echo=FALSE,out.width="100%", fig.align='center'} knitr::include_graphics("./images/cuerpo.png") ``` El cuerpo de una función puede contener: - Comprobación de argumentos - Manipulación de datos - Definición de resultados El cuerpo de la función puede tomar el mismo tipo de código utilizado en cualquier rutina de `R`. Sin embargo, los objetos creados no estarán disponibles en el entorno. Cuando se realizan varios cálculos, debemos incluir una *declaración de retorno* (return statement), que define explícitamente la salida de la función. Esto se hace usando la función `return()`: ```{r} # sin "return statement" f1 <- function(x, y) { z1 <- 2 * x + y z2 <- x + 2 * y z3 <- 2 * x + 2 * y z4 <- x / y } f1(5, 3) f1_out <- f1(5, 3) f1_out # con "return statement" f2 <- function(x, y) { z1 <- 2 * x + y z2 <- x + 2 * y z3 <- 2 * x + 2 * y z4 <- x / y return(c(z1, z2, z3, z4)) } f2(5, 3) f2_out <- f2(5, 3) f2_out ``` Por lo tanto, cuando no se proporciona una *declaración de retorno*, la función devolverá el último objeto que se creó en el cuerpo de la función: ```{r} # sin "return statement" f3 <- function(x, y) { z1 <- 2 * x + y z2 <- x + 2 * y z3 <- 2 * x + 2 * y z4 <- x / y c(z1, z2, z3, z4) } f3(5, 3) f3_out <- f3(5, 3) f3_out ``` Es más seguro usar `return()`. Cuando una función realiza varias tareas, podemos usar una lista para juntar los diferentes objetos. Esto es particularmente útil cuando se generan objetos de diferentes clases (por ejemplo, vectores y listas): ```{r} f4 <- function(x, y) { # 1 elemento z1 <- x + y # 2 elementos z2 <- c(x, y / 3) # vector logico z3 <- z2 < 10 l <- list(z1, z2, z3) return(l) } f4(10, 5) ``` Podemos acceder a elementos específicos de la salida de una función mediante indexación: ```{r} # elemento 1 f4(10, 5)[[1]] # elemento 2 f4(10, 5)[[2]] # elemento 3 f4(10, 5)[[3]] ``` Por supuesto, también podemos guardar el resultado como un objeto y acceder a cada elemento mediante la indexación: ```{r} # elemento 1 out <- f4(10, 5) # elemento 1 out[[1]] # elemento 2 out[[2]] ``` ::: {.alert .alert-info} ## Ejercicio 2 2.1 Cree una función llamada `promedio` que calcule el promedio de un vector numérico. Internamente solo puede utilizar las funciones `sum()` y `length()` (suma y división, no puede llamar la función `mean()`) 2.2 Cree una función que tome 2 argumentos numéricos (llámelos 'x' y 'y'), eleve cada uno al cuadrado y luego los sume 2.3 Agregue valores predeterminados a cada argumento 2.4 Ejecute la función usando los valores predeterminados 2.5 Ejecute la función usando un valor predeterminado y uno proporcionado en la llamada 2.6 Ejecute la función proporcionando ambos valores en la llamada ::: ------------------------------------------------------------------------ # Argumentos lógicos Son argumentos que pueden tomar solo dos valores: `TRUE` o `FALSE`. Estos argumentos permiten modificar el comportamiento de la función de forma binaria: si es `TRUE` llevaría a cabo la tarea 1 y si es `FALSE` llevaría a cabo la tarea 2. Internamente (i.e. en el cuerpo de las función) estas funciones implican el uso del operador `if`, algunas veces incluyendo su contra-parte `else`. Estos operadores son parte fundamental de la programación y se usan para definir que acción ejecutar con base en una evaluación lógica: ```{r} # creemos el objeto a con valor 2 a <- 2 # elevemos a la 2 si a es mayor q 0 if (a > 0) { a^2 } # elevemos a la 2 si a es mayor q 0 de lo contrario elevemoslo a la 100 if (a > 0) { a^2 } else { a^100 } # con a negativo a <- -3 if (a > 0) { a^2 } else { a^3 } ``` La parte dentro de los paréntesis justo después de `if` es la evaluación lógica. Estos operadores son utilizados en el cuerpo de la función cuando esta lleva un argumento lógico. Por ejemplo, la siguiente función utiliza un argumento lógico para decidir si la operación algebraica a realizar es una suma o un promedio: ```{r} mean_sum <- function(x, y, prom = FALSE) { if (prom) { b <- mean(c(x, y)) } else { b <- sum(c(x, y)) } return(b) } ``` Note que este tipo de argumentos deben tener un valor predeterminado. Podemos probar la función de la siguiente forma: ```{r} mean_sum(x = 2, y = 3) ``` ::: {.alert .alert-info} ## Ejercicio 3 3.1 Cree una función que tome 3 argumentos numéricos, multiplíquelos y luego calcule el logaritmo natural del resultado (función `log()`) 3.2 Agregue valores predeterminados a cada argumento 3.3 Ejecute la función con uno de los argumentos con un número negativo. ¿Qué pasa? ¿Por qué? 3.4 Agregue un argumento lógico que permita a los usuarios (si lo desean) convertir los argumentos de entrada a su valor absoluto (usando la función `abs()`). Agregue las modificaciones necesarias para que la función haga los cálculos con y sin valores absolutos. ```{r, eval = F, echo = F} # a) fcn_1 <- function(a, b, c) log(a * b * c) fcn_1(1, 4, 12) # b) fcn_1 <- function(a = 1, b = 2, c = 3) log(a * b * c) # c) fcn_1(1, 2, -1) ``` ::: ------------------------------------------------------------------------ # Ventajas de usar funciones ## Código mas limpio Los objetos creados dentro del cuerpo no están disponibles en el entorno actual: ```{r} # primero remover todo los objetos rm(list = ls()) f5 <- function(x) { sqr <- x * x lg_sqr <- log(x) return(lg_sqr) } f5(7) exists("sqr") exists("lg_sqr") ``` ```{r} x <- 7 sqr <- x * x lg_sqr <- log(x) exists("sqr") exists("lg_sqr") ``` ## Facil de correr y compartir Se pueden invocar funciones desde archivos de `R` externos sin estar definidas en el código actual con la función `source()`. En este ejemplo creamos la función `fnctn_X`: ```{r} fnctn_X <- function(sq_mt, vctr) { # trasponer matriz y calcular est dev stp1 <- t(sq_mt) stp2 <- vctr * vctr # guardar en lista rslt <- list(stp1, stp2) return(rslt) } fnctn_X(sq_mt = cbind(c(1, 2), c(3, 4)), vctr = c(2, 3)) ``` Guarde el código anterior en un archivo `R` llamado 'function_X.R'. Ahora la función se puede cargar usando `source()`: ```{r, eval = F} # removamosla del ambiente rm(fnctn_X) # cargar funcion source("function_X.R") # run it fnctn_X(sq_mt = cbind(c(1, 2), c(3, 4)), vctr = c(2, 3)) ``` ```{r, eval=T, echo=F} fnctn_X(sq_mt = cbind(c(1, 2), c(3, 4)), vctr = c(2, 3)) ``` Además, este código se puede compartir fácilmente. Se puede enviar por correo electrónico o publicar en línea. Incluso se puede cargar desde repositorios en línea: ```{r, error=T} # remover objetos rm(list = ls()) # revisar si existe en ambiente actual exists("fnctn_X") # cargar desde el internet source( paste0( "https://raw.githubusercontent.com/maRce10/", "r_avanzado_2023/master/data/function_x.r" ) ) # revisar si existe en ambiente actual exists("fnctn_X") ``` ## Se aplica fácilmente a nuevos objetos Esto ya debería ser obvio a este punto. ## Otros consejos - Construir funciones cortas: - Fácil de leer - Fácil de arreglar y actualizar - Si es demasiado largo, probablemente debería dividirse en varias funciones - Genera modularidad - Añadir comentarios a todo el código - Agregar descripciones a cada uno de los argumentos que toma - Función de prueba con diferentes valores/escenarios ------------------------------------------------------------------------ ::: {.alert .alert-info} ## Ejercicio 4 4.1 Cree una funcion que calcule el promedio, la desviación estándar y el error estándar de un vector numérico. Estos valores deben ser devueltos como una lista con nombres. 4.2 Permita a los usuarios ignorar los `NAs` (similar al argumento `na.rm` en `mean()`, pista: añada un argumento lógico) 4.3 Haga que la función además produzca un histograma del vector numérico proporcionado por el usuario 4.4 Haga que la función escoja un color al azar para las barras del histograma cada vez que se corre (pista: `sample(vector.de.colores, 1)`) 4.5 Añada un argumento a la función que permita el usuario, si lo desea, calcular la sumatoria (`sum()`) junto con el resto de los descriptores estadísticos 4.6 Agregue el promedio y la desviación estándar al título del histograma (pista: use `paste()`) 4.7 Modifique la función para que también cree una linea vertical indicando el promedio del vector numérico proporcionado por el usuario 4.8 Modifique la función para que añada un polígono transparente sobre el área que cubre el promedio +/- la desviación estándar (puede usar la función `rect()`) 4.9 Modifique la función con un argumento lógico que permita al usuario controlar si se crea un gráfico o no ::: ------------------------------------------------------------------------ ## Lecturas adicionales - <a href="http://nicercode.github.io/intro/writing-functions.html"> Introduction to R guide to writing functions with information for a total beginner</a> - <a href="https://twitter.com/hadleywickham">Information on functions for intermediate and advanced users (Hadley Wickham)</a>. - <a href="http://cran.r-project.org/doc/manuals/R-intro.html#Writing-your-own-R-intro.html#Writing-your-own-functions">The official R intro material on writing your own functions</a> (ir a "Writing your own function") ------------------------------------------------------------------------ ## Referencias - Wickham, Hadley, and Garrett Grolemund. 2016. *R for data science: import, tidy, transform, visualize, and model data*. [website](http://r4ds.had.co.nz) ------------------------------------------------------------------------ Información de la sesión ```{r session info, echo=F} sessionInfo() ```