Nombre de la función

Los nombres de las funciones tienen pocas restricciones, y siguen las mismas “reglas” que los nombres de otros objetos en R. Estas son algunas recomendaciones para nombrar funciones:

• No utilizar el nombre de objetos ya presentes o de nombres comunes de objetos (i.e. x o y)
• No utilizar el nombre de funciones comúnmente usadas
• No deben empezar con un número
• Deben dar alguna noción de la tarea que desempeñan
• No deben ser extremadamente largos

En caso de que existan varias funciones con el mismo nombre, estas pueden ser llamadas de forma separada usando el Namespace o nombre del paquete seguido del símbolo :: :

sd <- function(x) x^10

sd(1:5)

## [1]       1    1024   59049 1048576 9765625

stats::sd(1:5)

## [1] 1.581139

Especificar el Namespace antes de la función también puede ser usado para llamar funciones de paquetes que están instalados pero no han sido cargados en el ambiente actual (con library() o require()). Esto es especialmente útil cuando los nombres de las funciones de diferentes paquetes coinciden. También es común cuando se llaman funciones de otros paquetes dentro de un paquete.

Las funciones pueden ser “anónimas”:

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

## [1]       1    1024   59049 1048576 9765625

Esto es más útil cuando las funciones son usadas dentro de bucles (loops) con las funciones de la familia Xapply:

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

Argumentos

Los argumentos permiten al usuario ingresar los objetos (i.e. variables, matrices) sobre los cuales se llevarán a cabo el procedimiento de la función.

Los argumentos pueden tener valores por defecto, en cuyo caso no es obligatorio definirlos cuando la función es utilizada. En este ejemplo solo el segundo argumento tiene un valor por defecto. Por lo tanto el segundo argumento puede o no ser proporcionado por el usuario:

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

f1(1)

## [1] 3

Los argumentos por defecto se pueden modificar:

f1(3, 4)

Sin embargo el argumento que no tiene un valor por defecto debe ser proporcionado, sino la función produce un error:

f1()

## Error in f1(): argument "x" is missing, with no default

Si todos los argumentos tienen un valor por defecto las funciones se pueden llamar sin definir ningún argumento:

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

f1()

## [1] 0

 
Este es el caso de funciones como dev.off() y Sys.time():

Sys.time()

## [1] "2017-04-20 09:20:28 CST"

Cuando se llama una función los argumentos pueden ser especificados por posición, por nombres completos o por nombres parciales:

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

#por posicion + nombres
str(f2(a = 1, 2, 3))

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

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

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

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

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

#por posicion + nombres parciales
str(f2(1, a = 2, b1 =3))

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

Sin embargo, si los nombres parciales son ambiguos se genera un error:

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

## Error in f2(b = 1, 2, a = 3): argument 1 matches multiple formal arguments

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

Las funciones también pueden tomar argumentos lógicos. Estos son útiles (entre otras cosas) para modificar el comportamiento de la función en el momento de ser utilizada. Por ejemplo, la función mean() permite al usuario controlar si los NAs deben ser omitidos o no:

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

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

## [1] NA

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

## [1] 2

Los paquetes de R siguen un formato estándar de documentación en el cual cada función del paquete debe especificar claramente el tipo de objeto requerido por cada argumento. Podemos ver la documentación de una función poniendo un signo de pregunta seguido por el nombre de la función (sin paréntesis):

?mean

En R estudio también podemos acceder a la documentación poniendo el cursor sobre el nombre de la función y presionando F1.

Cuerpo de la función

El cuerpo de la función contiene la revisión de argumentos, manipulaciones de datos, los cálculos y la definición de resultados. El cuerpo se pueden utilizar las mismas herramientas que usamos en otros códigos de R. Sin embargo, los objetos creados dentro de una función no serán disponibles en el ambiente de trabajo (esto lo veremos más adelante).

Si tenemos una función que realiza varias tareas y por ende tiene muchos resultados para reportar, tenemos que incluir una expresión de retorno o “return statement”, para especificar que resultados serán devueltos. La expresión de retorno se genera usando la función return().

A continuación crearemos dos funciones similares, una en donde no tenemos la expresión de retorno y otra en la que si:

# Función 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.res <- f1(5, 3)
f1.res

## [1] 1.666667

# Función 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.000000 11.000000 16.000000  1.666667

f2.res <- f2(5, 3)
f2.res

## [1] 13.000000 11.000000 16.000000  1.666667

La función return() puede obviarse y se devolverá el último objeto creado:

# Función con "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.000000 11.000000 16.000000  1.666667

f3.res <- f3(5, 3)
f3.res

## [1] 13.000000 11.000000 16.000000  1.666667

Siempre es más seguro usar return().

Cuando tenemos una función que ejecuta múltiples procesos podemos guardar los resultados en una lista. Esto es especialmente útil cuando los elementos que se devuelven son de diferentes clases (e.g. vectores y matrices) o número de elementos:

f4 <- function(x, y) {
  
  # vector con 1 elemento
  z1 <- x + y
  
  # vector con 2 elementos
  z2 <- c(x, y/3)
  
  # vector lógico
  z3 <- z2 < 10
  
  
  l <- list(z1, z2, z3)
  
  return(l)
}

f4(10, 5)

## [[1]]
## [1] 15
## 
## [[2]]
## [1] 10.000000  1.666667
## 
## [[3]]
## [1] FALSE  TRUE

Cuando se devuelven listas podemos acceder nuestros resultados de forma independiente usando los indices de la lista (con paréntesis cuadrados dobles):

f4(10, 5)[[1]]

## [1] 15

f4(10, 5)[[2]]

## [1] 10.000000  1.666667

f4(10, 5)[[3]]

## [1] FALSE  TRUE

También podemos almacenar el resultado en una objeto:

resul <- f4(10, 5)
resul[[1]]

## [1] 15

resul[[2]]

## [1] 10.000000  1.666667

Código más limpio

Las funciones permiten la manipulación de objetos sin crear un gran número de objetos en los pasos intermedios. Este concepto es más fácil de entender con un ejemplo. La función f5() crea el objeto cuadr y logcuadr internamente. Sin embargo estos objetos no son añadidos al ambiente de trabajo:

# primero removamos todos los objetos en el ambiente
rm(list = ls())

f5 <- function(x) {
    cuadr <- x * x
    logcuadr <- log(x)
        return(logcuadr)
}


f5(7)

## [1] 1.94591

exists("cuadr")

## [1] FALSE

exists("logcuadr")

## [1] FALSE

Si esta operación se hiciera sin usar funciones los objetos si estarían en el ambiente, lo cual puede ser inconveniente (e.g. podría sobrescribir otros objetos):

x <- 7
    cuadr <- x * x
    logcuadr <- log(x)
      

exists("cuadr")

## [1] TRUE

exists("logcuadr")

## [1] TRUE

Las funciones ni siquiera tienen que ser definidas en el código en uso. Una función se puede guardar como un archivo de código de R y cargarla en el ambiente usando la función source():

sink(file="mi_super_funcion.R")
cat("funcionX <-")
funcion3
sink()

 #remover todos los objetos
rm(list = ls())

Ahora podemos llamar la función (ojo que le cambiamos el nombre a funcionX):

#cargar funcion
source("mi_super_funcion.R")

# aplicarla
funcionX(cuad.matriz = cbind(c(1, 2), c(3, 4)), vector = c(2, 3))

## [[1]]
##      [,1] [,2]
## [1,]    1    2
## [2,]    3    4
## 
## [[2]]
## [1] 4 9

Fácil de aplicar a nuevos objetos

Los procedimientos de programación “no-encapsulados” en una función generalmente están definidos para trabajar sobre objetos específicos. Por ejemplo, el siguiente código genera información sobre la estructura de un juego específico de datos (utilizaremos el juego de datos iris que viene por defecto en R):

head(iris)

##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1          5.1         3.5          1.4         0.2  setosa
## 2          4.9         3.0          1.4         0.2  setosa
## 3          4.7         3.2          1.3         0.2  setosa
## 4          4.6         3.1          1.5         0.2  setosa
## 5          5.0         3.6          1.4         0.2  setosa
## 6          5.4         3.9          1.7         0.4  setosa

?iris

# número de filas
nrow(iris)

## [1] 150

# número de columnas
ncol(iris)

## [1] 5

# número de variables numericas
length(which(sapply(iris, is.numeric)))

## [1] 4

# nombre de variables
names(iris)

## [1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width" 
## [5] "Species"

Si estuviéramos interesados en extraer esta información para un gran número de juegos de datos, tendríamos que cambiar el nombre del objeto en cada una de las funciones anteriores. En este caso construir una función nos permitiría aplicar el mismo procedimiento a cualquier otro juego de datos simplemente cambiando un único argumento:

info.bd <- function(bd) {

  l <- list(head = head(bd), 
          nrow = nrow(bd), 
          ncol = ncol(bd),
    n.num = length(which(sapply(bd, is.numeric))), 
    nombre.vars = names(bd))

return(l)
  }

info.bd(iris)

## $head
##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1          5.1         3.5          1.4         0.2  setosa
## 2          4.9         3.0          1.4         0.2  setosa
## 3          4.7         3.2          1.3         0.2  setosa
## 4          4.6         3.1          1.5         0.2  setosa
## 5          5.0         3.6          1.4         0.2  setosa
## 6          5.4         3.9          1.7         0.4  setosa
## 
## $nrow
## [1] 150
## 
## $ncol
## [1] 5
## 
## $n.num
## [1] 4
## 
## $nombre.vars
## [1] "Sepal.Length" "Sepal.Width"  "Petal.Length" "Petal.Width" 
## [5] "Species"

info.bd(iris3)

## $head
## [1] 5.1 4.9 4.7 4.6 5.0 5.4
## 
## $nrow
## [1] 50
## 
## $ncol
## [1] 4
## 
## $n.num
## [1] 600
## 
## $nombre.vars
## NULL

info.bd(CO2)

## $head
##   Plant   Type  Treatment conc uptake
## 1   Qn1 Quebec nonchilled   95   16.0
## 2   Qn1 Quebec nonchilled  175   30.4
## 3   Qn1 Quebec nonchilled  250   34.8
## 4   Qn1 Quebec nonchilled  350   37.2
## 5   Qn1 Quebec nonchilled  500   35.3
## 6   Qn1 Quebec nonchilled  675   39.2
## 
## $nrow
## [1] 84
## 
## $ncol
## [1] 5
## 
## $n.num
## [1] 2
## 
## $nombre.vars
## [1] "Plant"     "Type"      "Treatment" "conc"      "uptake"

Fácil de compartir

Al ser unidades de código discretas que son aplicables de forma general, las funciones pueden ser fácilmente compartidas y utilizadas por otros usuarios. En este ejemplo cargamos la función “info.bd” que creamos anteriormente desde un sitio remoto:

#remover todo
rm(list = ls())
ls()

## character(0)

#cargamos la funcion remotamente
source("http://marceloarayasalas.weebly.com/uploads/2/5/5/2/25524573/info.bd.r")

# ahora esta en el ambiente
ls()

## [1] "info.bd"

info.bd(CO2)

## $head
##   Plant   Type  Treatment conc uptake
## 1   Qn1 Quebec nonchilled   95   16.0
## 2   Qn1 Quebec nonchilled  175   30.4
## 3   Qn1 Quebec nonchilled  250   34.8
## 4   Qn1 Quebec nonchilled  350   37.2
## 5   Qn1 Quebec nonchilled  500   35.3
## 6   Qn1 Quebec nonchilled  675   39.2
## 
## $nrow
## [1] 84
## 
## $ncol
## [1] 5
## 
## $n.num
## [1] 2
## 
## $nombre.vars
## [1] "Plant"     "Type"      "Treatment" "conc"      "uptake"

Ejercicio 1

1. Cree una función llamada “mario” que tome 3 argumentos numéricos de un único elemento, los multiplique, y sobre ese resultado calcule el logaritmo natural (función log()).

2. Añada valores por defecto a cada uno de los argumentos.

3. Corra la función usando un número negativo para uno de los argumentos. ¿Qué sucede y por qué?

4. Añada un argumento lógico que permita usar los valores absolutos de los argumentos (usando la función abs()). Haga las modificaciones necesarias para que la función pueda (o no) calcular el absoluto de los argumentos dados.

Ejercicio 2

1. Usando la función tapply() calcule la desviación estandar de la talla para cada una de las especies en la base de datos de elasmobranquios.

2. De igual forma, calcule el error estandar de la talla para cada especie (pista: error estandar = desviación estandar/ raiz(n)).

3. Use la función de error estandar dentro de tapply() (i.e. de forma anónima, sin crear una función).

Ejercicio 3

1. Modifique la función plot.spp añadiendo un nuevo argumento que permita modificar los colores de las lineas e intervalos de confianza.

2. Añada un argumento lógico que permita remover los intervalos de confianza (pista: debe usar la función if).

Ejercicio 4

1. Utilizando los datos iris, cree una nueva función que produzca un gráfico de dispersión con “Sepal.Length” en el eje X y “Petal.Length” en el eje Y. La función debe permitir al usuario modificar el color, tamaño y tipo de símbolo (col, cex y pch). Además el titulo de la función debe contener el nombre de la especie y el valor de la correlación de pearson para estas variables (pista: debe usar las funciones cor() y paste()). La función debe ser aplicable a cualquiera de las 3 especies en iris. Aplique la función sobre una especie.

2. Utilice par y for-loop para hacer una gráfico multi-panel con 1 fila y 3 columnas con un gráfico de dispersión para cada especie en iris.

3. Modifique la función para que el usuario pueda escoger las variables que se graficarán y que estas aparezcan en el titulo de los ejes. Grafique “Petal.Length” en el eje X y “Sepal.Length” en el Y para las tres especies como en b).

4. Haga que el color de los puntos sea rojo si el valor de la correlación es mayor a 0.5. Grafíquelo para las 3 especies (pista: utilice ifelse).

5. Haga que el tamaño de los puntos sea proporcional al valor de la correlación. Grafíquelo para las 3 especies

6. Modifique la función de forma que haga un único gráfico con gráficos de dispersión (multi-panel, como en e)) para cada especie en el juego de datos. La función debe tomar el juego de datos iris. También debe ser capaz de ajustar el número de paneles en base al número de especies. Por ejemplo debe ser capaz de producir un gráfico de 2 paneles en el siguiente juego de datos:

sub.iris <- droplevels(iris[iris$Species != "virginica", ])

7. Añada un enunciado a la función de forma que si el juego de datos tiene menos de 2 especies devuelva un mensaje de error. Para esto debe usar la función stop() (e.g. stop(“la base de datos debe tener al menos 2 especies”)). Debe funcionar bien con la base de datos iris e sub.iris pero debe producir el mensaje cuando se aplica sobre la siguiente base de datos:

sub.iris2 <- droplevels(iris[iris$Species == "virginica", ])

Ejercicio 5

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

2. Úsela con las variables TL y dN15 de la base de datos de elasmobranquios.
   

3. ¿Cuáles argumentos son obligatorios (no tienen argumentos por defecto)?

4. ¿Qué hace el argumento alternative? Use valores diferentes de este argumento y compare los resultados.

5. ¿Cómo puedo obtener el coeficiente de Spearman? Calcúlelo.

6. ¿Qué tipo de objeto se obtiene cuando se guarda el resultado de esta función?

7. ¿Cómo podemos obtener únicamente el valor de p al correr esta función?