Práctica 3: Introducción a la programación en lenguaje R

1. CONSTANTES

• Valores numéricos: 5, -4.32, 1.5e-4, etc.
• Valores numéricos simbólicos: Inf (Infinite), NaN (Not a Number)
• Cadenas de texto: "a", 'b', "palabras de amor", etc. Entre comillas simples o dobles (para poder poner apóstrofes u otras comillas dentro).
• Lógicos: TRUE y FALSE.

2. VARIABLES Y ASIGNACIONES

• Nombre de variable: cualquier cadena de texto de letras y números (sin comillas y que no comience por número)
• Operador de asignación: =

2. VECTORES

• Es el tipo más basico de variable. Pueden ser de números, de cadenas de texto o de lógicos.
• Se crean y se “concatenan” con la función c(...).
• Vectores fáciles de crear:
  • Números consecutivos: función :
  • Números en progresión: función seq(from, to, length, by)
  • Repetición de un patrón: rep(x, times, each)
• Ejemplos:

c(0,2,4)
c("hola", "adiós", "hasta luego")
c(TRUE, TRUE, FALSE)
1:10
seq(from=0, to=1, length=5)
seq(from=0, to=1, by=0.1)
rep(x=1:3, each=10)
rep(x=1:3, times=5)
rep(x=1:3, times=c(5,2,4))

3. FUNCIONES

• Las funciones se invocan por su nombre y, entre paréntesis, los argumentos con su valor, separados por comas. A veces aparece el argumento ... (puntos suspensivos), que indican una cantidad indeterminada de argumentos.
• Ejemplo:

# Funció 'sample()' simula extracciones aleatorias de una urna de objetos
# Argumentos:
#   x: vector de los objetos de la urna
#   size: número de extracciones
#   replace: extracciones con restitución de los objetos?
#   prob: vector de probabilidades de los objetos (iguales por defecto)
sample(x=6, size=100, replace=TRUE, prob=NULL) # versió completa 
sample(6, 100, TRUE, NULL) # versió sin nombres de argument
sample(TRUE, 6, NULL, 100) # versió equivocando el orden de los argumentos
sample(100, 6, TRUE, NULL) # otra versió equivocando el orden de los argumentos
sample(replace=TRUE, x=6, prob=NULL, size=100) # versión ok 

• Definición de funciones: la estructura general es:

nombreFuncion = function(arg1, arg2, ...) {
  # cuerpo de la función
  # return(expression) # opcional
}

• donde:
  • nombreFuncion es el nombre que se quiere dar.
  • function es palabra reservada (para definir la función).
  • Argumentos:
    • No son obligatorios.
    • arg1 sería el primer argumento, arg2 el segundo, y puede haber más.
    • ... indica que puede haber más argumentos (que no se esperan, pero que el usuario puede pasar, si hacen falta)
    • Los argumentos se pueden igualar a algún valor para que tomen valor por defecto, y así el usuario se lo ahorra, si es muy habitual.
  • Cuerpo de la función: lleva las instrucciones a realizar.
  • Valor para devolver:
    • return(expression): la expressión puede ser el nombre de una variable del cuerpo de la función.
    • Es opcional. La función podría no devolver nada.
• Ejemplo:

# función que suma algunos términos de una série geométrica
# r^0 + r^1 + r^2 + ...
# pero que se pueda elegir dónde comienza y dónde acaba
serie.geom = function(razon=1, inicio=0, fin=0) {
  valores = razon^(inicio:fin)
return( sum(valores) )  
}
serie.geom(razon=2, inicio=0, fin=3)

## [1] 15

serie.geom(razon=2, fin=3) # observa cómo usa valores por defecto 

## [1] 15

serie.geom(inicio=0, fin=3)

## [1] 4

4. ALGUNAS FUNCIONES Y OPERACIONES IMPORTANTES CON VECTORES

• Operaciones aritméticas entre dos vectores:
  • +, -, *, /, ^, …
  • Actúan componente a componente y devuelven un vector numérico tan largo como el más largo de los argumentos
  • Si los vectores son de diferente longitud, el más corto se replica para poder continuar haciendo las operaciones
• Funciones matemáticas sobre un vector:
  • sqrt(), log(), exp(), sin(), abs(), … y otras -Actúan componente a componente y devuelven un vector igual de largo que el argumento
• Operadores de comparación entre dos vectores:
  • <, ==, >, <=, >=, != -Actúan componente a componente y devuelven un vector de lógicos
  • Si los vectores son de diferente longitud, el más corto se replica para poder continuar haciendo las operaciones
• Operadores lógicos entre dos vectores:
  • &, |, xor(), ! (and, or, or exclusivo, not) -Actúan componente a componente y devuelven un vector numérico tan largo como el más largo de los argumentos
  • Si los vectores son de diferente longitud, el más corto se replica para poder continuar haciendo las operaciones
• Otras funciones útiles sobre uno o más vectores:
  • ls() sin argumentos, devuelve el vector de nombres de las variables definidas.
  • a:b crea vector de enteros consecutivos, de a a b.
  • c(...) concatena los argumentos (constantes i/o vectores) en un solo vector.
  • length(x) devuelve la longitud del vector argumento x.
  • sum(...) SUMa las components de los (vectores) argumentos.
  • prod(...) PRODucto de las components de los (vectores) argumentos.
  • sort(x, decreasing=FALSE) devuelve un vector como el argumento, x, pero reordenado de manera creciente (a menos que se cambie el argumento decreasing a TRUE).
  • order(x, decreasing=TRUE) devuelve el vector de las “posiciones” del vector x que consiguen su ordenación (de manera creciente o decreciente, según sea el argumento decreasing).
  • min(...) devuelve el valor MÍNimo de los argumentos.
  • max(...) devuelve el valor MÀXimo de los argumentos.
  • which(x) devuelve el vector de “posiciones” donde el vector de lógicos, x, es TRUE. Normalmente x es una comparación, y which nos dice qué componentes cumplen la comparación.
  • diff(x) devuelve un vector con las diferencias (incrementos) de cada componente respecto del anterior
• Ejemplos:

v = 1:10
ls()
v^c(2,1)
v - 5
sqrt(v-5)
sort(c(5,-1,20,0,13,14))
order(c(5,-1,20,0,13,14))
diff(c(5,-1,20,0,13,14))

5. INDEXACIÓN DE VECTORES (SUBVECTORES)

• Operador [] con 3 posibles sintaxis:
  • Posiciones seleccionades
  • Posiciones excluidas
  • Lógicos para seleccionar (TRUE) y excluir (FALSE). Ideal para seleccionar datos de un vector que cumplan una condición concreta.
• Aplicación: investigar sobre el contenido del vector
• Ejemplo:

letters # vector de letras del abecedario (ya creado en R)
v = letters[1:5] # de la "a" a la "e"
v # miramos v
set.seed(2019) # para hacer simulaciones repetibles
# simulación de 100 letras de "a" a "e" equiprobables
w = sample(x=v, size=100, replace=TRUE)
w # miramos los datos simulados
# ¿cuántos datos tiene el vector?
length(w)
# ¿cuáles son los 10 primeros datos?
w[1:10]
# ¿y si me interesa descartar los 10 primeros datos?
w[-(1:10)]
# ¿cuántas letras "a" hay en el vector w?
w=="a" # hace comparaciones, y devuelve TRUEs y FALSEs (100 en total)
w[w=="a"] # selecciona de w solo las componentes de los TRUEs
length(w[w=="a"]) # finalmente cuenta cuántas hay
# ¿cuántas "vocales" hay en el vector w?
w[w=="a" | w=="e"] # seleccionamos las que son vocales
length(w[w=="a" | w=="e"]) # respuesta a la pregunta

6. MATRICES

• Son vectores (numéricos, de cadenas de texto, o lógicos) organizados en forma de filas y columnas
• Definición matrix(data, nrow, ncol, byrow=FALSE) donde:
  • data: vector a organizar en forma de matriz
  • nrow, ncol: número de filas y columnas (solo es necesario uno de los dos, el otro lo deduce de la longitud del vector)
  • byrow indica si la matriz se rellena por filas (por defecto NO)
• Indexación de matrices: operador [ , ] con dos argumentos
  • Antes de la coma: posición de fila (o vector con posiciones de filas) a seleccionar
  • Después de la coma: posición de columna (o vector con posiciones de columnas) a seleccionar
• Ejemplo:

m1 = matrix(data=1:12, nrow=3)
m1
m2 = matrix(data=1:12, nrow=3, byrow=TRUE)
m2
m2[3,4] # elemento
m2[2,] # fila 2
m2[,3] # columna 3
m2[c(1,3), c(2,3)] # submatriz

7. HOJAS DE DATOS

• Son conjuntos de vectores (de igual o distinta naturaleza), emparejados (todos de igual longitud), y organizado en columnas.
• Se parece a una matriz
• Definición: data.frame(etiq1=vector1, etiq2=vector2,...)
• Funciones interesantes: si se llama x a la hoja de datos y tiene como etiquetas de columna los nombres V1, V2, …, entonces:
  • length(x): número de columnas (!!!)
  • dim(x): dimensiones (filas, columnas)
  • names(x): vector con etiquetas de columnas
  • row.names(x): vector con etiquetas de filas
  • str(x): estructura (devuelve por pantalla un resumen del tipo de variable que es, de las componentes que la forman, y unos pocos de los valores que contiene. Vale para todo tipo de variable en R
• Indexación de hojas de datos ($ y [,]):
  • Extraer solo un vector columna. Por ejemplo:
    • x$V1: datos de la columna de etiqueta V1
    • x[ , "V1"]: datos de la columna de etiqueta V1
    • x[, 1]: datos de la primera columna
  • Extraer más de una columna alhora. Por ejemplo:
    • x[ , c("V1", "V3")]: datos de la columna de etiqueta V1
    • x[, c(1,3)]: datos de la primera columna
  • Extraer columnas, pero no completas.
    • Una columna: x$V1[condicion] o bien x[condicion, "V1"] (donde condicion es una condición que solo cumplen los datos que queremos extraer)
    • Varias columnas: x[condicion, c("V1", "V3")] (donde condicion es una condición que solo cumplen los datos que queremos extraer)
• Ejemplo:

data(mtcars) # carga hoja de datos "mtcars" en R
mtcars # miramos los datos
str(mtcars) # son demasiados datos. es mejor ver la estructura
names(mtcars) # miramos los nombres de las columnas
row.names(mtcars) # miramos los nombres de filas (cada fila, un coche)
# datos de la columna "mpg"
mtcars$mpg
# datos de columna "mpg" pero de coches con 4 cilindros (columna "cyl")
mtcars$mpg[mtcars$cyl==4]
# hoja de datos solo con columnas "disp" y "mpg" en este orden
mtcars[,c('disp', 'mpg')]
# hoja de datos solo con columnas "disp" y "mpg" en este orden
# pero solo de coches de 4 cilindros
mtcars[mtcars$cyl==4, c('disp', 'mpg')]

8. LISTAS

• Es una “lista” de cosas iguales o diferentes
• Definición: list(etiq1=obj1, etiq2=obj2,...) donde etiq1 y etiq2 son etiquetas (nombres sin comillas) y obj1 y obj2 son objetos de cualquier tipo (vectores, matrices, hojas de datos, etc.)
• Acceso a componentes de la lista ($ y [[]])
• Son útiles para guardar informaciones diversas de un mismo proceso.
• La mayoría de funciones “importantes” de R devuelven listas con piezas de información diferentes.
• Ejemplo:

# creamos una lista simple
l1 = list(mensaje="Ha funcionado", muestra=c(5.5, 10.4, 2.8), estad=4.8, facil=TRUE)
l1 # miramos la lista
l1[[2]] # accedemos a la segunda componente
l1[["muestra"]] # accedemos a la componente etiquetada como "muestra"
l1$muestra # accedemos a la componente etiquetada como "muestra"
# un ejemplo de lista creada por la función t.test() de R
contraste = t.test(x=1:10, mu=5, conf.level=0.99)
str(contraste) # miramos las etiquetas de la lista para poder acceder a ellas
contraste$p.value # devuelve el p-valor
contraste$conf.int # devuelve el intervalo de confianza

9. ESTRUCTURAS DE FLUJO

for(contador in vector) {
  # cuerpo del bucle
}

for(i in 1:3) { 
  warning("Step ", i, "!!!")
}

if(expresion) {
  # parte que se procesa si expresion==TRUE
} else {
  # parte que se procesa si expresion==FALSE
}

nota = 5.0
if(nota >= 5) {
  warning("Aprobado!")
} else {
  warning("Suspendido!")
}
nota = 4.9
if(nota >= 5) {
  warning("Aprovado!")
} else {
  warning("Suspendido!")
}

10. VECTORITZACIÓN

• R es un lenguatge interpretado, no compilado. Por eso es muy lento frente a otros lenguajes compilados: cada vez que se ejecuta un script, ha de interpretarse.
• La única cosa que R sabe hacer deprisa es trebajar con vectores y sus operaciones vectoriales (operadores, indexación, etc.)
• Por eso es fundamental NO HACER BUCLES for, si se puede trabajar directamente con el vectores y sus operaciones.
• Ejemplo: definir en R la función matemática \(f(x) = \left\{ \begin{array}{ll} x^2, & \text{ si } x \leq 1 \\ 2-x, & \text{ si } x > 1 \\ \end{array} \right.\) para que sea capaz de calcularse sobre vectores x.

# versión incorrecta (no vectorial)
funcionRara = function(x) {
  if(x <= 1) {
    return(x^2)
  } else {
    return(2-x)
  }
}
funcionRara(x=-1)
funcionRara(x=0)
funcionRara(x=1)
funcionRara(x=3)
funcionRara(x=c(-1,0,1,3))
#
# versión correcta (pero no vectorial!!!)
funcionRara2 = function(x) {
  y = numeric(length(x))
  for(i in 1:length(x)) {
    if(x[i] <= 1) {
      y[i] = x[i]^2
    } else {
      y[i] = 2 - x[i]
    }
  }
  return(y)
}
funcionRara2(x=-1)
funcionRara2(x=0)
funcionRara2(x=1)
funcionRara2(x=3)
funcionRara2(x=c(-1,0,1,3))
#
# versión correcta (y vectorial!!!)
funcioRara3 = function(x) {
  y = numeric(length(x))
  y[x<=1] = (x^2)[x<=1]
  y[x>1] = (2 - x)[x>1]
  return(y)
}
funcionRara3(x=-1)
funcionRara3(x=0)
funcionRara3(x=1)
funcionRara3(x=3)
funcionRara3(x=c(-1,0,1,3))
# la dibujamos
x = seq(from=-2, to=2, length=100)
y = funcionRara3(x)
plot(x=x, y=y, type='l') # para ver la gràfica

11. OTRAS FUNCIONES DE INTERÉS

• unique(): devuelve un vector con los valores (sin repetir) que contiene el vector argumento.
• diff(): calcula las diferencias entre cada componente y la anterior del vector argumento.
• eval(call("nombreFuncion", argumento)): produce la evaluación de la llamada de la función "nombreFuncion" con el argumento argumento. Importante para manipular funciones como argumento de otras funciones
• is.numeric(), is.na(), etc.: devuelve TRUE si el vector argumento es del tipo especificado en cada caso.
• Ejemplos:

unique(c(1,2,3,3,3,2,1,2,1))
diff(c(1,2,3,3,3,2,1,2,1))
eval(call("sum", 1:4))
is.numeric(1:3)
is.numeric(c("a", "b", "c"))

12. EJERCICIOS EVALUABLES

12.1. CONTRASTE DE HIPÒTESIS SIMPLES: Define la función que resuelve el contraste de hipótesis simples \[ \left\{ \begin{array}{ll} H_0: & f_X = f_0 \\ H_1: & f_X = f_1 \end{array} \right. \] que minimiza una combinación lineal de las probabilidades de error tipo I y II. Si la combinación es \(a \cdot \alpha(\delta) + b \cdot \beta(\delta)\), y la muestra es \(\vec{x} = (x_1, x_2, \ldots, x_n)\), entonces el procedimiento óptimo rechaza \(H_0\) si y solo si \(a \cdot f_0(\vec{x}) - b \cdot f_1(\vec{x}) < 0\).

• Los argumentos han de ser:
  • x: el vector con la muestra obtenida.
  • f0: el nombre de la función de densidad de probabilidad indicada en \(H_0\).
  • f1: el nombre de la función de densidad de probabilidad indicada en \(H_1\).
  • a, b: los pesos de la combinación lineal de los tipos de error
• La función ha de devolver:
  • El valor total calculado de \(a \cdot f_0(\vec{x}) - b \cdot f_1(\vec{x})\).
  • La frase “Rechazar \(H_0\)” o bien “Aceptar \(H_0\)” según corresponda al valor calculado.
• Comprobar la función con algunos ejemplos. Por ejemplo contrasta \(N(0,1)\) vs \(N(2,1)\) usando \(a=1\) y \(b=10\), y usando diversas muestras, del modelo \(N(0,1)\) y tambien del modelo \(N(2,1)\).

# Escribe aquí tu solución
# función contrasteHipotSimples()
# argumentos: ver enunciado
# calcular el valor a*f0(muestra) - b*f1(muestra)
# crear una lista con: (1) el valor calculado, y 
# (2) la frase "Aceptar H0" o "Rechazar H0", según corresponda
# devolver la lista creada

12.2. CONVERTIR DATOS NUMÉRICOS EN SIGNOS: Escribe una función num2signs() que tome un vector de datos numéricos (argumento x) y devuelva un vector de “signos” (con solo 2 números, como 0 y 1, o dos caracteres, como + y -).

• Si el argumento solo tiene 2 tipo de datos, se entiende que ya son signos, y el devuelve tal cual, sin hacerle nada.
• Si el vector tiene más de 2 tipos de datos, han de ser numéricos, y la función ha de devolver la cadena de signos:
  • Para fabricar la cadena de signos, el usuario puede indicar en un argumento, llamado type si quiere comparar cada dato con la mediana (type="median") o bien comparar cada dato con el anterior (type="increment").
  • Las comparaciones que den lugar a 0 (datos coincidentes con la mediana, o bien datos consecutivos iguales, segons el criterio usado), se excluirán del vector de signos final.
• Comprueba el funcionamento con pequeños ejemplos que demuestren que funciona bien.

# Escribe aquí tu solución

12.3. NÚMERO DE RACHAS: Escribe una función nruns() que, para un vector de datos de dos categorías (argumento x, por ejemplo, de números, o cualquier otra pareja de signos), devuelva el número de rachas existentes en el vector.

• Recuerda que una racha es una cadena máxima de valores iguales, situados entre valores del otro tipo, o extremos de la muestra (atención, que una racha puede ser un único signo).
• Si el vector tiene más de dos categorías, la función ha de devolver un mensaje de error, indicando que “el vector tiene más de dos signos!”.
• Comprueba el funcionamento con pequeños ejemplos que demuestren que funciona bien.

# Escribe aquí tu solución

12.4. LA DISTRIBUCIÓN DE PROBABILIDAD DEL NÚMERO DE RACHAS: Define en R la función de probabilidad de la variable aleatoria \(R\) = “número de rachas”, para un proceso de dos signos, en el cual se han observado \(n_1\) signos de un tipo y \(n_2\) signos del otro tipo. La función tendrá la forma druns(x, n1, n2), donde n1 y n2 son los argumentos de la cantidad de signos de cada tipo, y x puede ser cualquier valor posible, de manera que druns() devuelve la probabilidad de cualquier número de rachas posibles que se indique en x.

• Comprueba el funcionamento con pequeños ejemplos que demuestren que funciona bien.
• ¡Y que sea vectorial!
• La función de probabilidad de R=“número de rachas” és:
  • \(\displaystyle{P(R=2k)=\frac{2\binom{n_1-1}{k-1}\binom{n_2-1}{k-1}}{\binom{n_1+n_2}{n_1}}}\) (para los números pares)
  • \(\displaystyle{P(R=2k+1)=\frac{\binom{n_1-1}{k}\binom{n_2-1}{k-1}+\binom{n_2-1}{k}\binom{n_1-1}{k-1}}{\binom{n_1+n_2}{n_1}}}\) (para los números impares)

# Escribe aquí tu solución

12.5. CONTRASTE DE ALEATORIEDAD POR RACHAS: Implementa una función que realice el contraste de aleatoriedad (por rachas) para muestras pequeñas, según la estructura que se propone (usará las funciones de los ejercicios anteriores):

runs.test = function(x, type='median') {
# Argumentos:
#   x: vector de datos numéricos o signos
#   type: 'median' o 'increment', según el criterio para comparar
# Devuelve: el número de rachas y su p-valor

# bloque 1: comprobar si `x` son signos o números
# bloque 2: construir cadena de signos (si procede)
# bloque 3: calcular las rachas y su número
# bloque 4: calcular su p-valor. Si hay más de 20 signos de 
#           cada tipo, usar aprox. normal (busca fórmula en teoría)
#           y si no, la distribución exacta (ejercicio anterior)
# Al final:
#   return(list(R=, p.value=))
#     donde `R` es el valor del estadístico y
#     `p.value` su p-valor
#     recuerda que el p-valor es la probabilidad del valor observado de R
#     y también de otros valores que sean menos creíbles (para H0, y más para H1) que R  
}

12.6. PROGRAMAR UN NUEVO MODELO DE VARIABLE ALEATORIA EN R: Programa las 4 funciones de probabilidad del modelo “Tipy01” de parámetro \(\theta \in ]0,1[\) dado por las funciones:

• \(f(x) = \left\{ \begin{array}{ll} 0, & x <0 \\ \frac{2}{\theta} x, & 0 \leq x \leq \theta \\ \frac{2}{1 - \theta} (1-x), & \theta < x \leq 1 \\ 0, & x > 1 \end{array} \right.\)
• \(F(x) = \left\{ \begin{array}{ll} 0, & x <0 \\ \frac{1}{\theta} x^2, & 0 \leq x \leq \theta \\ 1 - \frac{1}{1 - \theta} (1-x)^2, & \theta < x \leq 1 \\ 1, & x > 1 \end{array} \right.\)

• \(X_p = F^{-1}(p) = \left\{ \begin{array}{ll} \sqrt{\theta p}, & 0 \leq p \leq \theta \\ 1 - \sqrt{(1 - \theta)(1-p)}, & \theta < p \leq 1 \end{array} \right.\)

• Recuerda llamarlas como es habitual en R:
  • dtipy01(x=, theta=) para la función de densidad de probabilidad , \(f(x)\).
  • ptipy01(q=, theta=) para la función de distribución (acumulada), \(F(x)\).
  • qtipy01(p=, theta=) para la función de cuantiles, \(X_p\).
  • rtipy01(n=, theta=) para la función de simulaciones.

• ¡Ha de ser vectorial! para poder calcular muchos valores a la vez.

# Escribe aquí tus funciones
#
# Después pruébalas con algunos valores
# dtipy(x=0.5, theta=0.5)
# ptipy(q=0.9, theta=0.1)
# qtipy(p=0.5, theta=0.1)
# rtipy(n=100, theta=0.1)
# También puedes dibujar la "f" en todo su dominio
# con distintos valores de theta para ver 
# las zonas de mayor densidad de probabilidad 
# x = seq(from=-1, to=2, by=0.01) # el eje x
# fx1 = dtipy(x=x, theta=0.2)
# plot(x=x, y=fx1, type='l')
# fx2 = dtipy(x=x, theta=0.5)
# points(x=x, y=fx2, type='l', lty=2)
# fx3 = dtipy(x=x, theta=0.8)
# points(x=x, y=fx2, type='l', lty=3)