Slides PDF

Programación Estadı́stica en R
Jocelyn Simmonds, Yasett Acurana
Departamento de Ciencias de la Computación

Universidad de Chile
JS, YA (DCC - UChile) Prog. Est. en R 1 / 136

Contenido
1 Introducción 3
Valores lógicos 21
Texto 36
Scripts 40
Funciones 50
Repetición 55
2 Objetos 61
Vectores 66
Factores 72
Arreglos y matrices 76
Listas y Data frames 89
3 Modelos lineales 101
4 Graficando datos cualitativos 109
5 Graficando datos cuantitativos 119
Introducción
Introducción

Introducción
¿Qué es la Programación Estadı́stica?
La Programación Estadı́stica es apoyar la tarea de análisis estadı́stico

mediante la programación.
Para esto, usaremos el ambiente de programación R1 :
R permite cargar y manipular datos
Provee funciones para hacer cálculos en base a objetos (vectores,
matrices, etc.)
Provee funciones para la visualización de datos
Incluye un lenguaje de programación que incorpora variables,
condicionales, bucles, y funciones definidas por el usuario
Software de libre acceso, disponible para Linux, OS X y Windows
1
https://www.r-project.org/
Introducción
Componentes de R
Consola: ejecutar comandos en forma interactiva

Scripts: programas que pueden ser ejecutados una y otra vez
Workspace: conjunto de objetos creados por el usuario (a través de la
consola, o ejecutando un script)
Plots: gráficos creados para visualizar los datos

Introducción
Trabajando con la consola de Linux

Introducción
Trabajando con RStudio
https://www.rstudio.com/
Introducción
Trabajando con la Consola de R
1 Crear directorio donde almacenaran sus datos, scripts y el workspace

2 Inicializar R (o RStudio) desde ese directorio
Podemos usar la consola como una calculadora simple:
1 > 12 * 23
2 [1] 276
3 > 5 ^ 2
4 [1] 25
El “[1]” indica la posición dentro del vector de respuestas.

Introducción
Creando variables
Pueden guardar sus cálculos, asignándolos a variables:
1 # el valor de 12 * 23 se guarda en la variable a

2 > a <- 12 * 23 # tambien pueden usar ’=’ para asignacion
3 > b <- 5 ^ 2
4 > a
5 [1] 276
6 > b
7 [1] 25
8 > a * b -> a # ojo con el sentido de la flecha!
9 > a
10 [1] 6900
Nombres de variables: A-Za-z0-9, además de “.” y “ ”.

Introducción
Vectores
El objeto más comúnmente usado para guardar datos en R es el vector:
1 > x <- c(1, 2, 3.5, 3.6, 5, 29, 1.4)

2 > x # todo lo que viene despues del # es un comentario
3 [1] 1.0 2.0 3.5 3.6 5.0 29.0 1.4
4 >
5 > vocales <- c("a", "e", "i", "o", "u")
6 > vocales
7 [1] "a" "e" "i" "o" "u"
La función c() toma un número arbitrario de argumentos, y retorna un

vector con estos elementos.

Introducción
Pruébenlo
Pueden usar el operador : para generar secuencias de números:
1 > x <- 1:15

2 > x
3 [1] 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
4 > y <- 30:1
5 > y
6 [1] 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6
7 [26] 5 4 3 2 1
8 > z <- 1.2:3.2
9 > z
10 [1] 1.2 2.2 3.2
Creen los siguientes vectores:

1 -5 -4 -3 -2 -1 0 1 2 3 4 5
2 1 2 3 3 2 1 1 2 3 (hint: y <- c(1:3, ..))

Introducción
Variables y vectores
Pueden combinar variables y vectores:
1 > a <- 4 * 7
2 > b <- 6 * 5
3 > c <- 9 * 2
4 >
5 > d <- c(c, a, b)
6 > d
7 [1] 18 28 30
8 >

Introducción
Posición de elementos
Pueden acceder a los elementos de un vector por posición:
1 > e <- c(22, 33, 44, 55)

2 > e
3 [1] 22 33 44 55
4 >
5 > e[1]
6 [1] 22
7 > e[2]
8 [1] 33
9 > e[length(e)]
10 [1] 55
La función length(x) retorna el largo de un vector:
1 > a <- 4 * 7
2 > length(a)
3 [1] 1

Introducción
Aritmética con vectores
Podemos realizar cálculos con vectores:

1 > x <- 1:10
2 > x
3 [1] 1 2 3 4 5 6 7 8 9 10
4 > x2 <- c(0, 2)
5 > z <- x + x2 # x2 se "recicla" tantas veces como sea necesario
6 > z # z[1] = x[1] + x2[1]
7 # z[2] = x[2] + x2[2]
8 # z[3] = x[3] + x2[1] ...
9 [1] 1 4 3 6 5 8 7 10 9 12
10 >
11 > y <- 1/x
12 > y
13 [1] 1.0000000 0.5000000 0.3333333 0.2500000 0.2000000 0.1666667 0.1428571
14 [8] 0.1250000 0.1111111 0.1000000
Operadores: +, -, *, /, ^ (potencia)

Introducción
Pruébenlo

1 los primeros 15 números cuadrados (1, 4, 9, 16, ... 225), sin usar c()
2 los números pares entre 10 y 40 (incluyendo ambos extremos)

Introducción
Funciones
R incluye varias funciones que podemos aplicar a variables y vectores:
1 > log(1)
2 [1] 0
3 > log(1:10)
4 [1] 0.0000000 0.6931472 1.0986123 1.3862944 1.6094379 1.7917595 1.9459101
5 [8] 2.0794415 2.1972246 2.3025851
6 > x3 <- c(2, 9, 1, 6, 7, 8, 4, 5, 3, 10)
7 > x3
8 [1]
9 > max(x3)
10 [1] 10
11 > min(x3)
12 [1] 1
13 > range(x3)
14 [1] 1 10
Formato de funciones: salida <- nombre de funcion(parametros)

Otras funciones: exp, sin, cos, sqrt, . . .

Introducción
Funciones
1 > x4 <- 1:5

2 > sum(x4)
3 [1] 15
4 > prod(x4)
5 [1] 120
6 > mean(x4) # equivalente a sum(x4)/length(x4)
7 [1] 3
8 > var(x4) # equivalente a sum((x4 - mean(x4))^2) / (length(x4) - 1)
9 [1] 2.5
10 > median(x4)
11 [1] 3
12 > sd(x4)
13 LLENAMEEEEEE
Pueden usar help(...) para ver todos los parámetros que recibe una
función.

Introducción
Secuencias de números
Podemos usar la función seq() para generar secuencias no-triviales de

números. Parámetros de seq():
desde x: from = x
hasta y: to = y
indicando la diferencia entre elementos: by = d (−d si from > to)
indicando el número de elementos: length = n
Ejemplo:
1 > seq(from = 4, to = 10, by = 0.5)
2 [1] 4.0 4.5 5.0 5.5 6.0 6.5 7.0 7.5 8.0 8.5 9.0 9.5 10.0
Ojo: no pueden usar los parámetros by y length al mismo tiempo.

Introducción
Pruébenlo

1 20 valores entre π y 2π (π se escribe pi en R)
2 0.500 0.495 0.490 0.485 ... 0.170 0.165 0.160 0.155 (sin usar el
parámetro length)

Introducción
Secuencias de números
seq(vector) genera un vector con los valores 1, 2, . . . length(vector):
1 > x <- NULL # vector no definido

2 > seq(x)
3 integer(0) # vector de enteros de largo 0 (vacio)
4 > x <- 10:1
5 > x
6 [1] 10 9 8 7 6 5 4 3 2 1
7 > y <- seq(x)
8 > y
9 [1] 1 2 3 4 5 6 7 8 9 10
Otras maneras de crear un vector vacio:

1 x <- integer(0)
2 x <- numeric(0)

Introducción Valores lógicos
Valores lógicos

Valores lógicos
R reconoce tres valores lógicos:

TRUE: verdadero
FALSE: falso
NA: dato no disponible
Operadores relacionales: <, <=, >, >=, ==, !=
1 > 1 > 0
2 [1] TRUE
3 > c(1, 4, 8) > 0
4 [1] TRUE TRUE TRUE
5 > c(1, 4, 8) >= 4
6 [1] FALSE TRUE TRUE
¿Qué pasa con los NA? lo veremos en la diapo 27 . . .

Vectores lógicos
1 > 31 %% 7 # resto de la division entre dos enteros

2 [1] 3
3 > r <- 31 %% 7
4 > a <- 31 %/% 7 # retorna la parte entera de la division
5 > 7 * a + r
6 [1] 31
7 >
8 > x <- seq(1, 10)
9 > x
10 [1] 1 2 3 4 5 6 7 8 9 10
11 > con <- x %% 2 == 0
12 > con
13 [1] FALSE TRUE FALSE TRUE FALSE TRUE FALSE TRUE FALSE TRUE
14 > sum(con)
15 [1] 5
TRUE y FALSE toman los valores 1 y 0 en cualquier calculo numérico.

Por ejemplo, TRUE + TRUE = 2

Pruébenlo
Queremos corregir una prueba de alternativas, donde las respuestas y la

pauta están guardadas en dos vectores:
1 > pauta = c(4, 2, 5, 1, 4, 3, 2, 5, 1, 3, 2)

2 > resp = c(4, 0, 5, 2, 4, 0, 2, 3, 1, 0, 1) # 0 indica respuesta omitida
Obtengan el número de respuestas correctas comparando los dos vectores.

Operadores lógicos
c1 & c2: conjunción

c1 | c2: disyunción
!c1: negación
1 > c1 <- c(TRUE, TRUE, FALSE, FALSE)

2 > c2 <- c(TRUE, FALSE, TRUE, FALSE)
3 > c1 & c2
4 [1] TRUE FALSE FALSE FALSE
5 > c1 | c2
6 [1] TRUE TRUE TRUE FALSE
7 > !c1
8 [1] FALSE FALSE TRUE TRUE
9 > !c2
10 [1] FALSE TRUE FALSE TRUE

Pruébenlo
Sigamos con el ejemplo de la prueba de alternativas:
1 > pauta = c(4, 2, 5, 1, 4, 3, 2, 5, 1, 3, 2)

2 > resp = c(4, 0, 5, 2, 4, 0, 2, 3, 1, 0, 1) # 0 indica respuesta omitida
1
Calculen el puntaje, ahora descontando 4 de punto por cada respuesta
incorrecta (exceptuando las omitidas).

Operadores lógicos
¿Qué pasa con los valores NA?
1 > c1 <- c(TRUE, TRUE, FALSE, FALSE)

2 > c2 <- c(TRUE, FALSE, TRUE, FALSE)
3 > c3 <- c(NA, NA, NA, NA)
4 > c1 & c3
5 [1] NA NA FALSE FALSE
6 > c2 & c3
7 [1] NA FALSE NA FALSE
8 > c1 | c3
9 [1] TRUE TRUE NA NA
10 > c2 | c3
11 [1] TRUE NA TRUE NA
12 > !c3
13 [1] NA NA NA NA

Cuidado: NA no es lo mismo que NaN
NA representa un elemento que falta en los datos de entrada, NaN

representa un resultado imposible de calcular:
1 > val <- 0/0

2 [1] NaN
3 >
4 > x <- 0:10
5 > x/0
6 [1] NaN Inf Inf Inf Inf Inf Inf Inf Inf Inf Inf
7 >
8 > is.nan(val)
9 [1] TRUE

Datos no disponibles
En la mayorı́a de los casos, operar sobre un NA produce un NA:
1 > 5 + NA
2 [1] NA
3 >
4 > a <- 5
5 > a + NA
6 [1] NA
7 >
8 > x <- c(2, 6, 2, NA, 6, 2, NA, 3, 4, NA, 9)
9 > x + 4
10 [1] 6 10 6 NA 10 6 NA 7 8 NA 13

Ignorando datos no disponibles
A veces queremos ignorar los NA, para esto usaremos la función

is.na(vector):
1 > x <- c(2, 6, 2, NA, 6, 2, NA, 3, 4, NA, 9)

2 > is.na(x)
3 [1] FALSE FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE FALSE
4 >
5 > x[is.na(x)]
6 [1] NA NA NA
7 >
8 > x[!is.na(x)]
9 [1] 2 6 2 6 2 3 4 9
OJO: la función is.na(x) retorna TRUE para elementos NA y NaN,

mientras que la función is.nan(x) solo retorna TRUE para elementos NaN.

Secuencias de ı́ndices
Podemos usar [] para seleccionar varios elementos de un vector al mismo

tiempo:
1 > x <- 0:10

2 > x
3 [1] 0 1 2 3 4 5 6 7 8 9 10
4 > x[x > 6]
5 [1] 7 8 9 10
6 > x[seq(1, length(x), by = 2)]
7 [1] 0 2 4 6 8 10
8 > x
9 > x[-3]
10 [1] 0 1 3 4 5 6 7 8 9 10
11 > x[-(5:0)]
12 [1] 5 6 7 8 9 10

Secuencias de ı́ndices
Podemos usar [] para modificar varios elementos de un vector al mismo

tiempo:
1 > x <- 0:10

2 > x
3 [1] 0 1 2 3 4 5 6 7 8 9 10
4 > x[x %% 2 == 0] <- 0
5 > x
6 [1] 0 1 0 3 0 5 0 7 0 9 0
7 >
8 > x <- 0:10
9 > x[x > 4] <- x[x > 4] + 4
10 > x
11 [1] 0 1 2 3 4 9 10 11 12 13 14
12 >

Pruébenlo
Dado el vector x <- c(3, 15, 9, 12, -1, 0, -12, 9, 6, 1),

escriban los comandos necesarios para lograr que:
1 se deje en 0 los elementos negativos de x
1 > y
2 [1] 3 15 9 12 0 0 0 9 6 1
2 se deje en 3 los elementos que son múltiplos de 3

1 > x
2 [1] 3 3 3 3 -1 3 3 3 3 1
3 se multiplica los elementos pares de x por 5

1 > x
2 [1] 3 15 9 60 -1 0 -60 9 30 1

Pruébenlo
Dado el vector x <- c(3, 15, 9, 12, -1, 0, -12, 9, 6, 1),

escriban los comandos necesarios para lograr que:
4 se deje los valores de x mayores que 10 en un nuevo vector
1 > x
2 [1] 15 12
5 se deje en 0 los elementos de x que son menores que el promedio

1 > x
2 [1] 0 15 9 12 0 0 0 9 6 0

Eligiendo elementos por condición
Se puede usar la función which() para encontrar las posiciones de los

elementos de un vector que cumplen una condición:
1 > x <- 1:10

2 > which(x %% 2 == 0)
3 [1] 2 4 6 8 10
4 >
5 > x2 <- runif(10, 2, 4.5) # genera numeros al azar (dist. uniforme)
6 > x2
7 [1] 3.966691 4.420197 3.243075 3.012766 3.617560 3.299832 2.524505 2.098100
8 [9] 2.113189 4.041362
9 > which(x2 >= mean(x2))
10 [1] 1 2 3 5 6 10

Introducción Texto
Texto

Texto
Se usan las comillas para crear secuencias de caracteres:
1 > x <- "hola"

2 > x
3 [1] "hola"
4 > y <- ’chao’
5 > y
6 [1] "chao"
7 > z <- "hola y chao"
8 > z
9 [1] "hola y chao"
10 > c(x, "y", y)
11 [1] "hola" "y" "chao"
12 > paste(x, "y", y)
13 [1] "hola y chao"

Texto
La función paste() se puede usar para generar los rótulos de un gráfico:
1 > labels <- paste("Libro", 1:10)

2 > labels
3 [1] "Libro 1" "Libro 2" "Libro 3" "Libro 4" "Libro 5" "Libro 6"
4 [7] "Libro 7" "Libro 8" "Libro 9" "Libro 10"
5 > labels2 <- paste("x", 1:10, 10:4)
6 > labels2
7 [1] "x 1 10" "x 2 9" "x 3 8" "x 4 7" "x 5 6" "x 6 5" "x 7 4" "x 8 10"
8 [9] "x 9 9" "x 10 8"
9 > labels3 <- paste("Lab", 1:10, sep="")
10 > labels3
11 [1] "Lab1" "Lab2" "Lab3" "Lab4" "Lab5" "Lab6" "Lab7" "Lab8" "Lab9"
12 [10] "Lab10"
Si alguno de los argumentos es más corto que el resto, se “repiten” los

elementos según sea necesario.

Pruébenlo

1 “x 1” “y 2” “x 3” “y 4” “x 5”
2 “x 1 10” “y 2 9” “x 3 8” “y 4 7” “x 5 10”

Introducción Scripts
Scripts

Agrupando expresiones
En R, se usan las llaves {...} para agrupar expresiones:
{expr 1; expr 2; ...expr n}
El “valor” de un grupo es el valor de la ultima expresión del grupo:
1 > x <- NULL

2 > y <- NULL
3 > mis_valores <- { x <- 1:10; y <- x^2 }
4 > x
5 [1] 1 2 3 4 5 6 7 8 9 10
6 > y
7 [1] 1 4 9 16 25 36 49 64 81 100
8 > mis_valores
9 [1] 1 4 9 16 25 36 49 64 81 100
Un grupo de expresiones es a la vez una expresión, pueden usar un grupo

en cualquier parte donde pueden colocar una expresión.
Ejecutando comandos desde un script

En un archivo llamado miprograma.R:
1 mis_valores <- { x <- 1:10; y <- x^2 }
2 otros_valores <- { lista <- mis_valores + 2 }
En R:
1 > source("miprograma.R")
2 > x
3 [1] 1 2 3 4 5 6 7 8 9 10
4 > y
5 [1] 1 4 9 16 25 36 49 64 81 100
6 > mis_valores
7 [1] 1 4 9 16 25 36 49 64 81 100
8 > lista
9 [1] 3 6 11 18 27 38 51 66 83 102
10 > otros_valores
11 [1] 3 6 11 18 27 38 51 66 83 102
En RStudio, “File” → “New File” → “R Script”. Editen y guarden

el archivo, presionando “Source” para ejecutar el script en la consola.
Ejecución condicional de expresiones
Podemos incluir condiciones usando if (cond) expr:
1 > x <- 1:10

2 > a
3 [1] 5
4 > if (a != 0) x <- x/a # en este caso, se ejecuta la expr del if
5 > x
6 [1] 0.2 0.4 0.6 0.8 1.0 1.2 1.4 1.6 1.8 2.0
7 >
8 > # en este caso, no se ejecuta la expr del if
9 > {x <- NULL; a <- 0; if (a != 0) x <- x/a }
10 > x
11 NULL
12 > a
13 [1] 0
Ojo: la condición debe producir un único valor lógico, o sea, la evaluación

de la condición debe generar un vector lógico de largo 1.

Ejecución condicional de expresiones
Podemos incluir caminos alternativos usando if ... else:

1 > a
2 [1] 5
3 > if (a > 1) x <- 1 else x <- 0
4 > x
5 [1] 1
6 >
7 > {x <- NULL; a <- 4; b <- 7; if (a - b > 0) x <- (b:a)^(a - b)
8 + else x <- (a:b)^(b - a)}
9 > x
10 [1] 64 125 216 343
De nuevo, la evaluación de la condición debe generar un único valor lógico.

Pruébenlo
1 Escriba un script que toma un número y indica si es par o impar.

Pueden usar la funcion cat() para imprimir mensajes en la consola, y
readline() para pedir valores en forma interactiva. Ejemplos:
1 > x <- 2
2 > cat(x, "es numero par\n")
3 2 es numero par
4 >
5 > x <- as.integer(readline("Ingrese un numero entero: "))
6 64353 # ingresado por el usuario
7 > x
8 [1] 64353
2 Escriba un script que tome dos números enteros e indique si la

división es exacta o no.

Condiciones compuestas
Los operadores & y | se aplican sobre vectores, elemento por elemento

Caso especial: si una condición es acerca de vectores de largo 1,
podemos usar los operadores && y ||.
expr 1 && expr 2: si expr 1 es FALSE, no se evalúa expr 2
expr 1 || expr 2: si expr 1 es TRUE, no se evalúa expr 2
Ejemplos:
1 > # no se imprime el mensaje "12 es mayor que 5" porque "0 == 1" es falso
2 > {a <- 12; if (0 == 1 && a > 5) cat(a, "es mayor que 5")}
3 >
4 > # se imprime el mensaje, porque "1 == 1" es siempre verdadero
5 > {a <- 3; if (1 == 1 || a > 5) cat(a, "es mayor a 5")}
6 [1] "3 es mayor a 5"

Cadenas de if . . . else
Pueden ejecutar cadenas de instrucciones if . . . else:
1 > cliente <- "habitual"

2 > descuento <-
3 + {if (cliente == "habitual"){
4 + descuento <- 0.1
5 + } else if (cliente == "semi-habitual"){
7 + } else {
9 + }}
10 >
11 > descuento
12 [1] 0.1

Ejecución condicional sobre vectores
Existe una versión del if para condiciones sobre vectores:

ifelse(cond, vector 1, vector 2)
1 > labels
2 [1] "Libro 1" "Libro 2" "Libro 3" "Libro 4" "Libro 5" "Libro 6"
3 [7] "Libro 7" "Libro 8" "Libro 9" "Libro 10"
4 > digits
5 [1] "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"
6 > ifelse(as.integer(digits) %% 2 == 0, digits, labels)
7 [1] "0" "Libro 2" "2" "Libro 4" "4" "Libro 6"
8 [7] "6" "Libro 8" "8" "Libro 10"
9 >
Esta instrucción retorna un vector de largo max(vector 1, vector 2),

donde en la i-esima posición tiene por valor vector 1[i] si cond[i] es
TRUE, sino tiene por valor vector 2[i].

Pruébenlo
Use ifelse(cond, ...) para escribir un script que imite el

comportamiento de pmax2 para dos vectores de números.
Ejemplo:
1 > x <- c(49,79,03,35,878,04,43,03)
2 > y <- c(76,34,56,98,009,56,43,76)
3 > pmax(x, y)
4 [1] 76 79 56 98 878 56 43 76
2
Parallel max: máximo componente a componente, para uno o más vectores
Introducción Funciones
Funciones

Creando una función
Pueden crear funciones usando la función function:

nombre funcion <- function(parametro 1, parametro 2, ...)
1 potencia_vec <- function(x, n){

2 y <- x^n
3 }
Guarden sus funciones en un archivo .R y usen source() para cargarlas a

la consola.
1 > valores <- potencia_vec(1:10, 3)
2 > valores
3 [1] 1 8 27 64 125 216 343 512 729 1000

¿Script o función? Parámetros . . .
Funciones reciben parámetros, o sea, podemos ejecutar un mismo “script”

muchas veces, solo alterando los parámetros con que invocamos la función:

2 > valores
3 [1] 1 8 27 64 125 216 343 512 729 1000
5 > valores
6 [1] 25 36 49 64 81 100 121 144 169

¿Script o función? Asignaciones locales . . .

Toda asignación que ocurre dentro de una función es local, o sea, es
temporal y se pierde al terminar la ejecución de la función:
1 > potencia_vec
2 function(x, n){
3 y <- x^n
4 }
5 > y <- NULL
6 > x <- NULL
7 > n <- NULL
9 > x
10 NULL
11 > n
12 NULL
13 > y
14 NULL
15 > valores
16 [1] 1 8 27 64 125 216 343 512 729 1000

Valores por defecto
Pueden asignar valores por defecto cuando definen una función:
1 > potencia_vec
2 function(x, n=2){
3 y <- x^n
4 }
5 > potencia_vec(1:10)
6 > valores <- potencia_vec(1:10)
7 > valores
8 [1] 1 4 9 16 25 36 49 64 81 100
9 > valores <- potencia_vec(1:10, n=4)
10 > valores
11 [1] 1 16 81 256 625 1296 2401 4096 6561 10000
12 > valores <- potencia_vec(1:10)
13 > valores
14 [1] 1 4 9 16 25 36 49 64 81 100

Introducción Repetición
Repetición

Repitiendo instrucciones: for
Podemos repetir instrucciones usando for (var in expr 1) expr 2:
Definición de función: Salida en consola:

1 convertir <- function(x){ 1 > x <- c(-3, 4, 5, -2, -9, 5)
2 for (i in 1:length(x)){ 2 > convertir(x)
3 if (x[i] < 0) 3 [1] 3 4 5 2 9 5
4 x[i] <- -1 * x[i]
5 }
6 x
7 }
Es usual que expr 1 sea un vector de ı́ndices.
Ojo: este es un ejemplo académico para mostrar como funciona el for. En

general, es mas eficiente procesar vectores “en bloque” que uno a uno.

Pruébenlo
1 Escriba una función suma(vector), que tome como parámetro un

vector y entregue la suma de los elementos de este (sin usar la
función sum()).
2 Escriba una función indice(vector, valor), que retorne el ı́ndice
de la primera ocurrencia de valor en vector. Si valor no se
encuentra en vector, retorne el valor 0.

Repitiendo instrucciones: repeat
Podemos repetir instrucciones usando repeat.

1 imprimir <- function(){ 1 > imprimir()
2 i <- 1 2 [1] 1
3 repeat { 3 [1] 2
4 if (i == 5) break 4 [1] 3
5 print(i); 5 [1] 4
6 i <- i + 1; 6 >
7 }
8 }
La única forma de finalizar un ciclo repeat es usando un break.

Repitiendo instrucciones: while
Podemos repetir instrucciones usando while (cond) expr:

1 potencias2 <- function(){ 1 > potencias2()
2 i <- 0 2 [1] "0 1"
3 while (2^i < 1000){ 3 [1] "1 2"
4 print(paste(i, 2^i)); 4 [1] "2 4"
5 i <- i + 1 5 [1] "3 8"
6 } 6 [1] "4 16"
7 } 7 [1] "5 32"
8 [1] "6 64"
9 [1] "7 128"
10 [1] "8 256"
11 [1] "9 512"
Pueden usar break para terminar el ciclo en forma temprana, y pueden

usar next para avanzar a la siguiente iteración.

Pruébenlo
Un jugador debe lanzar dos dados numerados de 1 a 6, y su puntaje es la

suma de los valores obtenidos.
Un puntaje dado puede ser obtenido con varias combinaciones posibles.

Por ejemplo, el puntaje 4 se logra con las siguientes dos combinaciones:
1+3 y 2+2.
Escriba una funcion que recibe como parámetro un puntaje, y muestra

como resultado la cantidad de combinaciones de dados con las que se
puede obtener ese puntaje.

Objetos
Objetos

Objetos
Tipos de objetos
vector: secuencia de elementos, todos del mismo tipo

factor: vector especial para manejar datos categóricos
arreglo: colección de elementos de datos, organizados en varias
dimensiones (p.ej., cubo de 3×3×3)
matriz: arreglo de dos dimensiones
lista: secuencia de elementos, pueden ser de cualquier tipo
(incluyendo listas)
data frame: lista de vectores del mismo largo

Objetos
Propiedades de objetos
Todo objeto x tiene al menos dos propiedades:

1 mode(x): indica el “tipo” del objeto. Ejemplos: numeric, logical,
character, etc.
2 length(x): indica el “tamaño” del objeto (no siempre es útil)
1 > x <- 1:10

2 > mode(x)
3 [1] "numeric"
4 > length(x)
5 [1] 10
6 >
7 > x <- "hola"
8 > mode(x)
9 [1] "character"
10 > length(x)
11 [1] 1

Objetos
Cambio de mode()
Existen varias funciones as.xxxxx(objeto), que permiten cambiar el

mode() de un objeto.
1 > z <- 0:9

2 > digitos <- as.character(z)
3 > digitos
4 [1] "0" "1" "2" "3" "4" "5" "6" "7" "8" "9"
5 >
6 > d <- as.integer(digitos)
7 > d
8 [1] 0 1 2 3 4 5 6 7 8 9
9 > d == z
10 [1] TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE TRUE
También existen varias funciones is.xxxxx(objeto), que retornan TRUE

si el objeto es del tipo en el nombre de la función.

Objetos
Pruébenlo
1 Creen un vector de números decimales, vean que pasa cuando aplican

as.integer()
2 ¿Qué pasa si le aplican as.integer() a un vector de texto?
3 . . . y a un vector de valores lógicos?

Objetos Vectores
Vectores

Objetos Vectores
Cambiando el tamaño de un vector
Podemos asignar valores en posiciones mayores que el largo actual:
1 > x <- integer(15)

2 > x
3 [1] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
4 >
5 > e <- integer() # vector de largo 0
6 > e[3] <- 17
7 > e
8 [1] NA NA 17 # ojo que rellena con NA en vez de 0
9 > e[10] <- 3
10 > e
11 [1] NA NA 17 NA NA NA NA NA NA 3

Objetos Vectores
Cambiando elementos del vector
Podemos cambiar elementos usando el complemento:
1 > e
2 [1] NA NA 17 NA NA NA NA NA NA 3
3 > e[-2] <- 4 # asignar 4 a todo menos la posicion 2
4 > e
5 [1] 4 NA 4 4 4 4 4 4 4 4
6 > e[2] <- 1.3
7 > e
8 [1] 4.0 1.3 4.0 4.0 4.0 4.0 4.0 4.0 4.0 4.0
9 > mode(e)
10 [1] "numeric"
11 > e[c(1, 5, 8)] <- "abc"
12 > e
13 [1] "abc" "1.3" "4" "4" "abc" "4" "4" "abc" "4" "4"
14 >
Noten que el vector pasa a ser de tipo numeric por la asignación en la

linea 6, y character por la asignación en la linea 11.

Objetos Vectores
Cambiando el tamaño de un vector
También podemos cambiar el valor de length():
1 > f
2 [1] 4 4 NA NA NA
3 >
4 > length(f) <- 3
5 > f
6 [1] 4 4 NA
7 >
8 > length(f) <- 13
9 > f
10 [1] 4 4 NA NA NA NA NA NA NA NA NA NA NA
En general, no recomiendo hacer esto . . .

Objetos Vectores
Concatenación de elementos
Podemos agregar nuevos elementos a la cola del vector usando c():
1 > x <- NULL

2 > x <- c(x, 2)
3 > x
4 [1] 2
5 > x <- c(x, 4)
6 > x
7 [1] 2 4
8 > x <- c(x, 6)
9 > x
10 [1] 2 4 6
11 > x <- c(x, 8)
12 > x
13 [1] 2 4 6 8
14 >

Objetos Vectores
Pruébenlo
Creen el vector x de largo 15:

1 asignen el valor 1.4 a las posiciones 2, 7 y 9
2 asignen el valor 2.8 a las posiciones 4, 8 y 12
3 . . . y 1 al resto.

Objetos Factores
Factores

Objetos Factores
Factores
Podemos crear un factor de un vector de datos categóricos:
1 > x <- c("rojo", "azul", "rojo", "rojo", "azul")

2 > fact_x <- factor(x)
3 > fact_x
4 [1] rojo azul rojo rojo azul
5 Levels: azul rojo # siempre se muestran en orden lexicografico
6 >
7 > levels(fact_x)
8 [1] "azul" "rojo"
9 >
10 > y <- c("rojo1", "azul", "rojo2", "rojo11", "azul")
11 > fact_y <-factor(y)
12 > fact_y
13 [1] rojo1 azul rojo2 rojo11 azul
14 Levels: azul rojo1 rojo11 rojo2
Los Levels de un factor son las categorı́as que hay en los datos.

Objetos Factores
Factores: uso
Los factores se usan para calcular funciones como el promedio o suma en

forma agregada por categorı́a:
1 > fact_x
3 Levels: azul rojo
4 > datos <- 1:5
5 > tapply(datos, fact_x, sum)
6 azul rojo
7 7 8
8 > tapply(datos, fact_x, mean)
9 azul rojo
10 3.500000 2.666667
11 > tapply(datos, fact_x, max)
12 azul rojo
13 5 4
datos y el vector usado para crear fact x debe ser del mismo largo.

Objetos Factores
Combinando factores
La función tapply() recibe como segundo parámetro una lista de factores:
1 > fact_x
3 Levels: azul rojo
4 > datos <- 1:5
5 >
6 > genero <- c("H", "H", "F", "F", "F")
7 > fact_g <- factor(genero)
8 > tapply(datos, list(fact_x, fact_g), sum)
9 F H
10 azul 5 2
11 rojo 7 1
12 > table(x, fact_g) # pueden usar table para contar los cruces
13 fact_g
14 x F H
15 azul 1 1
16 rojo 2 1

Objetos Arreglos y matrices
Arreglos y matrices

Creando un arreglo
En R, un arreglo es un vector con “dimensiones”:
1 > z <- numeric(1500)

2 > z
3 [1] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
4 [38] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
5 ...
6 [1444] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
7 [1481] 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
8 >
9 > dim(z)
10 NULL

Creando un arreglo
1 > dim(z) <- c(3,5,100)

2 > z
3 ...
4 , , 99
5
6 [,1] [,2] [,3] [,4] [,5]
7 [1,] 0 0 0 0 0
8 [2,] 0 0 0 0 0
9 [3,] 0 0 0 0 0
10
11 , , 100
12
13 [,1] [,2] [,3] [,4] [,5]
14 [1,] 0 0 0 0 0
15 [2,] 0 0 0 0 0
16 [3,] 0 0 0 0 0
17 > dim(z) <- c(3,6,100)
18 Error in dim(z) <- c(3, 6, 100) :
19 dims [product 1800] do not match the length of object [1500]

Creando un arreglo
Puede redefinir las dimensiones si es consistente con número de elementos:
1 > dim(z) <- c(30,50)
2 > z
3 [,1] [,2] [,3] [,4] [,5] [,6] [,7] [,8] [,9] [,10] [,11] [,12] [,13]
4 [1,] 0 0 0 0 0 0 0 0 0 0 0 0 0
5 [2,] 0 0 0 0 0 0 0 0 0 0 0 0 0
6 ...
7 [30,] 0 0 0 0 0 0 0 0 0 0 0 0 0
8 ...
9 ...
10 [,38] [,39] [,40] [,41] [,42] [,43] [,44] [,45] [,46] [,47] [,48] [,49]
11 [1,] 0 0 0 0 0 0 0 0 0 0 0 0
12 [2,] 0 0 0 0 0 0 0 0 0 0 0 0
13 ...
14 [30,] 0 0 0 0 0 0 0 0 0 0 0 0
15 [,50]
16 [1,] 0
17 [2,] 0
18 ...
19 [30,] 0

Orden de elementos
Los elementos de un arreglo están ordenados por columnas. En otras

palabras, la matriz
11 12 13
M=
21 22 23
se crea de la siguiente forma:
1 > M <- c(11, 21, 12, 22, 13, 23)

2 > dim(M) <- c(2, 3)
3 > M
4 [,1] [,2] [,3]
5 [1,] 11 12 13
6 [2,] 21 22 23
7 >

Acceder a elementos por posición
Usaremos [] para acceder a los elementos de un arreglo por posición:
1 > z <- numeric(1500)

2 > dim(z) <- c(3,5,100)
3 > z[1,1,99] <- 1
4 > z[,,99] # se muestra la matriz completa del nivel 99
5 [,1] [,2] [,3] [,4] [,5]
6 [1,] 1 0 0 0 0
7 [2,] 0 0 0 0 0
8 [3,] 0 0 0 0 0
Si omitimos una posición, R incluye la columna/fila completa.

1 > z[1,1,99] <- 1

2 > z[,,99]
3 [,1] [,2] [,3] [,4] [,5]
4 [1,] 1 0 0 0 0
5 [2,] 0 0 0 0 0
6 [3,] 0 0 0 0 0
7 > z[1,3,99] <- 3
8 > z[,,99]
9 [,1] [,2] [,3] [,4] [,5]
10 [1,] 1 0 3 0 0
11 [2,] 0 0 0 0 0
12 [3,] 0 0 0 0 0
13 > z[1,,98:100]
14 [,1] [,2] [,3]
15 [1,] 0 1 0
16 [2,] 0 0 0
17 [3,] 0 3 0
18 [4,] 0 0 0
19 [5,] 0 0 0
20 >

Una vez que hayamos indicado las dimensiones de un arreglo, podemos

usar dim() para ver las dimensiones actuales del arreglo:
1 > dim(z)
2 [1] 3 5 100
De todas formas, podemos acceder a los elementos del arreglo

directamente por su posición en el vector de datos:
1 > z[1,1,99] <- 1

2 > z[1]
3 [1] 0
4 > z[1470] # 3 x 5 x 98
5 [1] 0
6 > z[1471]
7 [1] 1

Otra forma de crear un arreglo
También podemos crear un arreglo en un solo paso, usando la función

array(vector de datos, dim = vector de dimensiones):
1 > x <- array(1:20, dim=c(4,5))

2 > x
3 [,1] [,2] [,3] [,4] [,5]
4 [1,] 1 5 9 13 17
5 [2,] 2 6 10 14 18
6 [3,] 3 7 11 15 19
7 [4,] 4 8 12 16 20
Ojo: si el vector de datos es más corto que el número de elementos

especificados por las dimensiones, el vector de datos se “reusa” hasta
completar el arreglo.

Arreglos de posiciones
Podemos crear un “arreglo de posiciones” para modificar un arreglo:
1 > x <- array(1:20, dim=c(4,5))

2 > i <- array(c(1, 2, 3, 4, 1, 3), dim=c(3, 2))
3 > i
4 [,1] [,2]
5 [1,] 1 4
6 [2,] 2 1
7 [3,] 3 3
8 > x[i] <- 0
9 > x
10 [,1] [,2] [,3] [,4] [,5]
11 [1,] 1 5 9 0 17
12 [2,] 0 6 10 14 18
13 [3,] 3 7 0 15 19
14 [4,] 4 8 12 16 20
Ojo: posiciones negativas generan un error; posiciones con algún 0 son

ignorados.

Matrices
Matrices son arreglos de 2 dimensiones, pueden ser incluidas en

expresiones aritméticas:
1 > C <- array(c(4, 3, 3, 2), dim=c(2,2))

2 > C
3 [,1] [,2]
4 [1,] 4 3
5 [2,] 3 2
6 >
7 > C + 2
8 [,1] [,2]
9 [1,] 6 5
10 [2,] 5 4
11 >
12 > C * C # ojo! * no es multiplicacion de matrices!
13 [,1] [,2]
14 [1,] 16 9
15 [2,] 9 4

Operaciones sobre matrices
Sean A, D matrices, b, x vectores y n una constante:

t(A): retorna A traspuesta
nrow(A): retorna el número de filas de A
ncol(A): retorna el número de columnas de A
A %*% B: retorna el producto de las matrices A, B
det(A): retorna el determinante de A
diag(A): retorna un vector con la diagonal principal de A
diag(x): retorna una matriz diagonal, donde los elementos de la
diagonal son los valores de x
diag(n): retorna una matriz identidad de n × n
solve(A, b): resuelve el sistema de ecuaciones lineares A · x = b
solve(A): retorna la matriz inversa de A

Pruébenlo
Resuelvan el siguiente sistema de ecuaciones lineales:
2x + y − 2z = 10
3x + 2y + 2z = 1
5x + 4y + 3z = 4

Objetos Listas y Data frames
Listas y Data frames

Listas: elementos de cualquier tipo
ex es una lista de tres elementos: uno de tipo character, uno de tipo

integer y uno de tipo vector
1 > ex <- list(nombre="Juan", num.hijos=2, edades.hijos=c(4, 7))

2 > ex
3 $nombre
4 [1] "Juan"
5
6 $num.hijos
7 [1] 2
8
9 $edades.hijos
10 [1] 4 7

1 > ex <- list(nombre="Juan", num.hijos=2, edades.hijos=c(4, 7))

2 > ex[3]
3 $edades.hijos
4 [1] 4 7
5
6 > ex[["num.hijos"]]
7 [1] 2
8 >
9 > ex[[3]]
10 [1] 4 7
11 >
12 > ex[[3]][1]
13 [1] 4
14 >
15 > ex$edades.hijos
16 [1] 4 7
17 >
18 > ex$edades.hijos[2]
19 [1] 7


R no revisa que los nombres de los elementos de una lista sean únicos, lo
que puede causar errores a futuro:
1 > ex2 <- list(x=1, y=2, x=3)

2 > ex2
3 $x
4 [1] 1
5
6 $y
7 [1] 2
8
9 $x
10 [1] 3
11
12 > ex2[["x"]] # toma el primer elemento con nombre = x
13 [1] 1
14 > ex2[[1]]
15 [1] 1
16 > ex2[[3]]
17 [1] 3

Editando una listas

Pueden usar c() para unir listas:
1 > ex3 <- c(ex, ex2)
2 > ex3
3 $nombre
4 [1] "Juan"
5
6 $num.hijos
7 [1] 2
8
9 $edades.hijos
10 [1] 4 7
11
12 $x
13 [1] 1
14
15 $y
16 [1] 2
17
18 $x
19 [1] 3

Editando una listas
Tambien pueden usar length() para acortar una lista:
1 > length(ex3)
2 [1] 6
3 > length(ex3) <- 3
4 > ex3
5 $nombre
6 [1] "Juan"
7
8 $num.hijos
9 [1] 2
10
11 $edades.hijos
12 [1] 4 7

Data frame
Un data frame es una lista donde todas las columnas son del mismo largo:
1 > mtcars
2 mpg cyl disp hp drat wt qsec vs am gear carb
3 Mazda RX4 21.0 6 160.0 110 3.90 2.620 16.46 0 1 4 4
4 Mazda RX4 Wag 21.0 6 160.0 110 3.90 2.875 17.02 0 1 4 4
5 Datsun 710 22.8 4 108.0 93 3.85 2.320 18.61 1 1 4 1
6 Hornet 4 Drive 21.4 6 258.0 110 3.08 3.215 19.44 1 0 3 1
7 Hornet Sportabout 18.7 8 360.0 175 3.15 3.440 17.02 0 0 3 2
8 Valiant 18.1 6 225.0 105 2.76 3.460 20.22 1 0 3 1
9 ...
Un data frame incluye nombres de filas y nombres de columnas.
R trae varios data frames de prueba, pueden listarlos usando la función

data().

Creando un data frame
Pueden crear un data frame de las siguientes formas:

de forma manual, usando la función data.frame(),
convirtiendo una lista de listas, usando la función as.data.frame(),
. . . o cargando los datos de un archivo externo, usando la función
read.table()

Leyendo datos de un archivo de texto

Para usar read.table(), los datos deben estar en el siguiente formato:
la primera fila del archivo tiene los nombres de las n columnas
el resto de las filas contienen los datos de los registros (n + 1 datos
porque incluye un identificador de fila)
Ejemplo: houses.data
1 Price Floor Area Rooms Age Cent.heat
2 01 52.00 111.0 830 5 6.2 no
3 02 54.75 128.0 710 5 7.5 no
4 03 57.50 101.0 1000 5 4.2 no
5 04 57.50 131.0 690 6 8.8 no
6 05 59.75 93.0 900 5 1.9 yes
Ahora podemos cargar los datos:

1 > # archivo debe estar dentro del workspace
2 > prices <- read.table("houses.data")

Acceso a los componentes de un data frame
Usaremos el signo $ para indicar la componente que nos interesa:
1 > prices <- read.table("houses.data")

2 > prices
3 Price Floor Area Rooms Age Cent.heat
4 01 52.00 111 830 5 6.2 no
5 02 54.75 128 710 5 7.5 no
6 03 57.50 101 1000 5 4.2 no
7 04 57.50 131 690 6 8.8 no
8 05 59.75 93 900 5 1.9 yes
9 > prices$Floor
10 [1] 111 128 101 131 93
11 > prices[[1]]
12 [1] 52.00 54.75 57.50 57.50 59.75
13 > prices["03", "Rooms"]
14 [1] 5
15 > prices["03", 1:5]
16 Price Floor Area Rooms Age
17 03 57.5 101 1000 5 4.2

Creando un data frame en forma manual

Pueden crear un data frame a partir de vectores existentes:
1 > nombres <- c("Ana Maria", "Doris", "Paula", "Pedro", "Juan")

2 > apellidos <- c("Jerez", "Said", "Soto", "Perez", "Soto")
3 > edades <- c(23, 65, 44, 45, 33)
4 > personas <- as.data.frame(list(nombres, apellidos, edades))
5 > personas
6 c..Ana.Maria....Doris....Paula....Pedro....Juan..
7 1 Ana Maria
8 2 Doris
9 3 Paula
10 4 Pedro
11 5 Juan
12 c..Jerez....Said....Soto....Perez....Soto.. c.23..65..44..45..33.
13 1 Jerez 23
14 2 Said 65
15 3 Soto 44
16 4 Perez 45
17 5 Soto 33
Falta crear los nombres de las componentes.

Creando un data frame en forma manual
Pueden usar names() para definir los nombres de las componentes de un

data frame:
1 > names(personas) <- c("Nombre", "Apellido", "Edad")
2 > personas
3 Nombre Apellido Edad
4 1 Ana Maria Jerez 23
5 2 Doris Said 65
6 3 Paula Soto 44
7 4 Pedro Perez 45
8 5 Juan Soto 33
9 > personas$Apellido
10 [1] Jerez Said Soto Perez Soto
11 Levels: Jerez Perez Said Soto
12 > personas$Edad
13 [1] 23 65 44 45 33

Modelos lineales
Modelos lineales

Modelos lineales
Cargando unos datos
Primero cargaremos unos datos acerca de iniciativas de planificación

familiar de paı́ses latinoamericanos:
1 > pfam <- read.table("effort.dat")

2 > head(pfam, 3)
3 setting effort change
4 Bolivia 46 0 1
5 Brazil 74 0 10
6 Chile 89 16 29
7 > summary(pfam)
8 setting effort change
9 Min. :35.0 Min. : 0.00 Min. : 0.00
10 1st Qu.:66.0 1st Qu.: 3.00 1st Qu.: 5.50
11 Median :74.0 Median : 8.00 Median :10.50
12 Mean :72.1 Mean : 9.55 Mean :14.30
13 3rd Qu.:84.0 3rd Qu.:15.25 3rd Qu.:22.75
14 Max. :91.0 Max. :23.00 Max. :40.00
15 >

Modelos lineales
Examinando los datos

Podemos usar la función identify() para identificar puntos de los
gráficos en forma interactiva:
1 > plot(pfam$effort, pfam$change)
2 > identify(pfam$effort, pfam$change, row.names(pfam), ps=10)
3 # elegir algunos puntos del grafico (este debe estar activo)
4 # hacer right-click para terminar de identificar puntos
5 [1] 2 6 10 13 20

Modelos lineales
Modelo lineal
La función lm() genera un modelo lineal de los datos:
1 > modelo = lm(pfam$change ~ pfam$setting + pfam$effort)
El parámetro principal de lm() es una formula: la variable a la izquierda

del ˜ se modela en base a la formula a la derecha. Pueden usar los
siguientes operadores:
+ para combinar variables: A + B
: para incluir interacciones entre variables: A : B
* para incluir variables y sus interacciones: A ∗ B, que es equivalente
a A+B +A:B
A y B tambien pueden ser factores.

Modelos lineales
Resumen de un modelo lineal
Pueden ver un resumen del modelo generado:
1 > summary(modelo)
2 Call:
3 lm(formula = pfam$change ~ pfam$setting + pfam$effort)
4
5 Residuals:
6 Min 1Q Median 3Q Max
7 -10.3475 -3.6426 0.6384 3.2250 15.8530
8
9 Coefficients:
10 Estimate Std. Error t value Pr(>|t|)
11 (Intercept) -14.4511 7.0938 -2.037 0.057516 .
12 pfam$setting 0.2706 0.1079 2.507 0.022629 *
13 pfam$effort 0.9677 0.2250 4.301 0.000484 ***
14 ---
15 Signif. codes: 0 ’***’ 0.001 ’**’ 0.01 ’*’ 0.05 ’.’ 0.1 ’ ’ 1
16
17 Residual standard error: 6.389 on 17 degrees of freedom
18 Multiple R-squared: 0.7381, Adjusted R-squared: 0.7073
19 F-statistic: 23.96 on 2 and 17 DF, p-value: 1.132e-05

Modelos lineales
Elementos de un modelo lineal
Pueden hacer más que graficar el modelo lineal:
1 > esfuerzo <- fitted(modelo)

2 > esfuerzo
3 1 2 3 4 5 6 7 8
4 -2.004026 5.572452 25.114699 21.867637 28.600325 24.146986 17.496913 10.296380
5 9 10 11 12 13 14 15 16
6 14.364491 9.140694 -2.077359 6.122912 31.347518 11.878604 3.948921 26.664898
7 17 18 19 20
8 8.475593 5.301864 22.794043 16.946453
9 > coef(modelo)
10 (Intercept) pfam$setting pfam$effort
11 -14.4510978 0.2705885 0.9677137

Modelos lineales
Usando factores
También pueden crear modelos lineales usando factores:
1 > effort_fact <- cut(pfam$effort, breaks = c(-1, 4, 14, 100),

2 + label=c("weak","moderate","strong"))
3 > effort_fact
4 [1] weak weak strong strong strong strong moderate moderate
5 [9] moderate moderate weak moderate strong weak weak strong
6 [17] weak weak strong moderate
7 Levels: weak moderate strong
8 > nuevo_modelo <- lm(pfam$change ~ pfam$setting + effort_fact)
9 > nuevo_modelo
10 Call:
11 lm(formula = pfam$change ~ pfam$setting + effort_fact)
12
13 Coefficients:
14 (Intercept) pfam$setting effort_factmoderate
15 -5.9540 0.1693 4.1439
16 effort_factstrong
17 19.4476
El primer nivel del factor es el valor de referencia.

Modelos lineales
Usando factores
1 > summary(nuevo_modelo)
2
3 Call:
4 lm(formula = pfam$change ~ pfam$setting + effort_fact)
5
6 Residuals:
7 Min 1Q Median 3Q Max
8 -10.0386 -2.8198 0.1036 1.3269 11.4416
9
10 Coefficients:
11 Estimate Std. Error t value Pr(>|t|)
12 (Intercept) -5.9540 7.1660 -0.831 0.418
13 pfam$setting 0.1693 0.1056 1.604 0.128
14 effort_factmoderate 4.1439 3.1912 1.299 0.213
15 effort_factstrong 19.4476 3.7293 5.215 8.51e-05 ***
16 ---
17 Signif. codes: 0 ’***’ 0.001 ’**’ 0.01 ’*’ 0.05 ’.’ 0.1 ’ ’ 1
18
19 Residual standard error: 5.732 on 16 degrees of freedom
20 Multiple R-squared: 0.8016, Adjusted R-squared: 0.7644
21 F-statistic: 21.55 on 3 and 16 DF, p-value: 7.262e-06

Graficando datos cualitativos

Datos cualitativos
Hemos visto que podemos usar factores para categorizar datos:
1 > head(mtcars, 5)
2 mpg cyl disp hp drat wt qsec vs am gear carb
3 Mazda RX4 21.0 6 160 110 3.90 2.620 16.46 0 1 4 4
4 Mazda RX4 Wag 21.0 6 160 110 3.90 2.875 17.02 0 1 4 4
5 Datsun 710 22.8 4 108 93 3.85 2.320 18.61 1 1 4 1
6 Hornet 4 Drive 21.4 6 258 110 3.08 3.215 19.44 1 0 3 1
7 Hornet Sportabout 18.7 8 360 175 3.15 3.440 17.02 0 0 3 2
8 > mtcars$cyl
9 [1] 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4 4 8 8 8 8 4 4 4 8 6 8 4
10 >
11 > fact_cyl <- factor(mtcars$cyl)
12 > fact_cyl
13 [1] 6 6 4 6 8 6 8 4 4 6 6 8 8 8 8 8 8 4 4 4 4 8 8 8 8 4 4 4 8 6 8 4
14 Levels: 4 6 8
Usen help(nombre data set) para ver la descripción de un dataset

disponible en R.

Pruébenlo
El paquete MASS contiene varios datasets, como painters y crabs.

Para usar estos datasets, primero deben cargar el paquete MASS:
1 > library(MASS)
Exploren los datasets painters y crabs del paquete MASS. ¿Cuáles

columnas son factores, o candidatos a factores?

Distribución de frecuencia
Pueden usar la función table() para calcular la frecuencia de ocurrencia

de cada categorı́a de un factor:
1 > table(painters$School)
2 A B C D E F G H
3 10 6 6 10 7 4 7 4
4 >
5 > table(fact_cyl)
6 fact_cyl
7 4 6 8
8 11 7 14
9 > table(crabs$sex, crabs$sp)
10
11 B O
12 F 50 50
13 M 50 50

Estadisticas sobre categorias
table() solo cuenta ocurrencias, deben usar tapply() para calcular

estadı́sticas sobre cruces de categorı́as:
1 > tapply(crabs$FL, list(crabs$sp, crabs$sex), mean)

2 F M
3 B 13.270 14.842
4 O 17.594 16.626
5 >
6 > tapply(painters$Composition, painters$School, mean)
7 A B C D E F G H
8 10.400000 12.166667 13.166667 9.100000 13.571429 7.250000 13.857143 14.000000

Distribución de frecuencia relativa
Frecuencia
Frecuencia relativa =
Tamaño muestra
Calculamos la distribución de frecuencia relativa usando table() y
nrow():
1 > freq_painters <- table(painters$School)

2 > freq_painters
3
4 A B C D E F G H
5 10 6 6 10 7 4 7 4
6 > rel_freq <- freq_painters/nrow(painters)
7 > rel_freq
8
9 A B C D E F G
10 0.18518519 0.11111111 0.11111111 0.18518519 0.12962963 0.07407407 0.12962963
11 H
12 0.07407407

Cambiando las opciones de R
1 > rel_freq
2
3 A B C D E F G
4 0.18518519 0.11111111 0.11111111 0.18518519 0.12962963 0.07407407 0.12962963
5 H
6 0.07407407
7 > options(digits=1)
8 > rel_freq
9
10 A B C D E F G H
11 0.19 0.11 0.11 0.19 0.13 0.07 0.13 0.07
12 > options(digits=3)
13 > rel_freq
14
15 A B C D E F G H
16 0.1852 0.1111 0.1111 0.1852 0.1296 0.0741 0.1296 0.0741

Graficando la distribución de frecuencia

1 > freq_painters <- table(painters$School)
2 > barplot(freq_painters) # grafica en pantalla
3 >
4 > png("mi_archivo.png") # dejara el grafico en mi_archivo.png
5 > barplot(freq_painters)
6 > dev.off() # cierra el "device", copiando los
7 > # contenidos al archivo
8 >
9 > x11() # o windows() si estan en Windows
10 > barplot(freq_painters, ylab = "numero de pintores", ylim = c(0,12),
11 + main="Distribucion de pintores por escuela")

Graficando la distribución de frecuencia

También podemos generar gráficos de torta:
1 > pie(freq_painters)
2 >
3 > # con otros colores
4 > colores = c("red", "yellow", "green", "violet", "orange", "blue",
5 + "pink", "cyan")
6 > pie(freq_painters, col = colores)

Otra forma de guardar gráficos
Pueden guardar un grafico generado en pantalla en forma directa, usando

dev.copy():
1 > pie(freq_painters, col = colores)

2 > dev.copy(png, "piechart.png")
3 png
4 4
5 > dev.off()
6 png
7 2
Al hacer dev.copy(), cambian el valor del device actual al indicado.

Graficando datos cuantitativos

Primero debemos generar una partición del rango de los datos:
1 > head(crabs$FL, 20) # tamanno del lobulo frontal [mm]

2 [1] 8.1 8.8 9.2 9.6 9.8 10.8 11.1 11.6 11.8 11.8 12.2 12.3 12.6 12.8 12.8
3 [16] 12.9 13.1 13.1 13.3 13.9
4 >
5 > range(crabs$FL)
6 [1] 7.2 23.1
7 >
8 > cortes <- seq(6.0, 24.0, by=2)
9 > length(cortes)
10 [1] 10
11 > crabs.cut.FL <- cut(crabs$FL, cortes, right=FALSE)
12 > crabs.cut.FL
13 [1] [8,10) [8,10) [8,10) [8,10) [8,10) [10,12) [10,12) [10,12) [10,12)
14 [10] [10,12) [12,14) [12,14) [12,14) [12,14) [12,14) [12,14) [12,14) [12,14)
15 [19] [12,14) [12,14) [14,16) [14,16) [14,16) [14,16) [14,16) [14,16) [14,16)
16 ...
17 [190] [20,22) [20,22) [20,22) [20,22) [20,22) [20,22) [20,22) [20,22) [20,22)
18 [199] [22,24) [22,24)
19 9 Levels: [6,8) [8,10) [10,12) [12,14) [14,16) [16,18) [18,20) ... [22,24)

Ahora podemos usar table() y barplot():
1 > freq.FL <- table(crabs.cut.FL)
2 > freq.FL
3 crabs.cut.FL
4 [6,8) [8,10) [10,12) [12,14) [14,16) [16,18) [18,20) [20,22) [22,24)
5 1 11 21 31 47 35 31 18 5
6 > barplot(freq.FL, ylim=c(0, 50), main="Distribucion de largo de lobulo
7 + frontal", ylab="frecuencia", xlab="largo de lobulo frontal [mm]")

Tambien podemos usar la funcion hist() para generar histogramas:
1 > hist(crabs$FL, right=FALSE)

Distribución de frecuencia relativa y acumulada
Podemos reutilizar los intervalos que calculamos antes usando cut() para
ahora calcular las distribuciones de frecuencia relativa y acumulada:
1 > freq.FL <- table(crabs.cut.FL)

2 >
3 > relfreq.FL <- freq.FL / nrow(crabs)
4 > relfreq.FL
5 crabs.cut.FL
6 [6,8) [8,10) [10,12) [12,14) [14,16) [16,18) [18,20) [20,22) [22,24)
7 0.005 0.055 0.105 0.155 0.235 0.175 0.155 0.090 0.025
8 >
9 > acumfreq.FL <- cumsum(freq.FL)
10 > acumfreq.FL
11 [6,8) [8,10) [10,12) [12,14) [14,16) [16,18) [18,20) [20,22) [22,24)
12 1 12 33 64 111 146 177 195 200

Generando un gráfico de la frecuencia acumulada

1 > acumfreq0.FL <- c(0, cumsum(freq.FL)) # cortes[1] es 6
2 > plot(cortes, acumfreq0.FL, # plot(vector_x, vector_y, ..
3 + main="Lobulo frontal del cangrejo Leptograpsus variegatus",
4 + xlab="tamano [mm]", ylab="frecuencia acumulada")
5 > lines(cortes, acumfreq0.FL)

Gráfico de dispersión (scatter plot)

Para ver la relación entre dos variables numéricas, podemos usar un
gráfico de dispersión:
1 > plot(crabs$FL, crabs$CL, xlab="tamano del lobulo frontal [mm]",
2 + ylab="tamano del caparazon [mm]", main="cangrejo Leptograpsus variegatus")

Gráfico de dispersión (scatter plot)

En este caso, hay una clara relación linear positiva entre las dos variables.
Podemos usar abline() y lm() para agregar una linea de tendencia:
1 > plot(crabs$FL, crabs$CL, xlab="tamano del lobulo frontal [mm]",
2 + ylab="tamano del caparazon [mm]", main="cangrejo Leptograpsus variegatus")
3 > abline(lm(crabs$CL ~ crabs$FL))

Cuartiles
Podemos dividir los datos en cuartiles:

primer cuartil (cuartil inferior o Q1): la mediana de la primera mitad
de los datos
segundo cuartil (el cuartil medio o Q2): es la mediana
tercer cuartil (cuartil superior o Q3): la mediana de la segunda mitad
de los datos
1 > quantile(crabs$FL)
2 0% 25% 50% 75% 100%
3 7.20 12.90 15.55 18.05 23.10
El rango intercuartil se define como Q3 - Q1:
1 > IQR(crabs$FL)
2 [1] 5.15

Percentiles
Los percentiles son los 99 valores que dividen la serie de datos en 100
partes iguales. Por ejemplo:
P10 es el valor que separa el primer 10% de los valores de los datos,
cuando se ordenan en forma ascendente
P50 es la mediana
1 > quantile(crabs$FL, c(.10, .25, .67, .89))

2 10% 25% 67% 89%
3 10.980 12.900 17.400 20.011

Gráfico de caja (box-and-whiskers)
1 > boxplot(crabs$FL, horizontal=TRUE, xlab="distribucion de tamano de

2 + lobulo frontal [mm]", main="cangrejo Leptograpsus variegatus")

Gráfico de caja (box-and-whiskers)

También pueden mostrar distribuciones por alguna categorı́a:
1 > boxplot(Composition ~ School, data=painters, ylab="Composition scores")

Covarianza y el coeficiente de correlación
La covarianza de dos variables da una idea de cuanto varı́an estas

variables en forma conjunta.
El coeficiente de correlación indica la magnitud de la correlación:
positiva (valor cercano a 1), negativa (valor cercano a -1) o sin
relación (valor cercano a 0).
1 > cov(crabs$FL, crabs$CL)

2 [1] 24.356677
3 >
4 > cor(crabs$FL, crabs$CL)
5 [1] 0.97884179
Podemos concluir que hay una correlación positiva entre el tamaño del
caparazón y del lóbulo frontal en el cangrejo Leptograpsus variegatus.

Gráficos con colores

Definir colores en base a algún factor:
1 > library(MASS)
2 > head(crabs, n = 1)
3 sp sex index FL RW CL CW BD
4 1 B M 1 8.1 6.7 16.1 19.0 7.0
5 > plot(crabs$FL, crabs$CL) # primer grafico
6 > colores <- c("blue", "orange")[crabs$sp]
7 > head(colores, n = 3)
8 [1] "blue" "blue" "blue"
9 > tail(colores, n = 3)
10 [1] "orange" "orange" "orange"
11 > plot(crabs$FL, crabs$CL, col=colores) # segundo grafico
12 > plot(crabs$CL ~ crabs$FL, col=colores) # tercer grafico

Gráficos con colores

Definir colores en base a alguna formula sobre los datos:
1 > malos_comp <- ifelse(painters$Composition < mean(painters$Composition),
2 "orange", "darkgreen")
3 > malos_comp
4 [1] "orange" "darkgreen" "orange" "darkgreen" "orange" "darkgreen"
5 ...
6 > barplot(painters$Composition, col = malos_comp, ylim = c(0, 20))
7 > abline(h = mean(painters$Composition), lty = 2, col = "red")

Lineas de tendencia
La función abline recibe varios parametros:

h = n: linea horizontal que corta al eje Y en el valor n
v = n: linea vertical que corta al eje X en el valor n
a = n, b = m: linea y = a + bx
lty = n: blank (0), solid (1), dashed (2), dotted (3), dotdash (4),
longdash (5), twodash (6). Valor por defecto: 1
lwd = n: n > 0 es el ancho de la linea
col = color: red, green, etc.

Gráficos resumen
Pueden usar plot() o pairs() para generar gráficos de resumen:
1 > colores <- c("blue", "orange")[crabs$sp]
2 > plot(crabs) # primer grafico
3 > plot(crabs, col=colores) # segundo grafico

Gráficos resumen
1 > coplot(crabs$CL ~ crabs$FL | crabs$sp) # primer grafico

2 > coplot(crabs$CL ~ crabs$FL | crabs$sp + crabs$sex) # segundo grafico

Slides PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Slides PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Programación Estadı́stica en R

Jocelyn Simmonds, Yasett Acurana

Departamento de Ciencias de la Computación

JS, YA (DCC - UChile) Prog. Est. en R 1 / 136

JS, YA (DCC - UChile) Prog. Est. en R 3 / 136

¿Qué es la Programación Estadı́stica?

La Programación Estadı́stica es apoyar la tarea de análisis estadı́stico

Consola: ejecutar comandos en forma interactiva

JS, YA (DCC - UChile) Prog. Est. en R 5 / 136

Trabajando con la consola de Linux

JS, YA (DCC - UChile) Prog. Est. en R 6 / 136

Trabajando con RStudio

Trabajando con la Consola de R

1 Crear directorio donde almacenaran sus datos, scripts y el workspace

El “[1]” indica la posición dentro del vector de respuestas.

JS, YA (DCC - UChile) Prog. Est. en R 8 / 136

Pueden guardar sus cálculos, asignándolos a variables:

1 # el valor de 12 * 23 se guarda en la variable a

Nombres de variables: A-Za-z0-9, además de “.” y “ ”.

JS, YA (DCC - UChile) Prog. Est. en R 9 / 136

El objeto más comúnmente usado para guardar datos en R es el vector:

1 > x <- c(1, 2, 3.5, 3.6, 5, 29, 1.4)

La función c() toma un número arbitrario de argumentos, y retorna un

JS, YA (DCC - UChile) Prog. Est. en R 10 / 136

Pueden usar el operador : para generar secuencias de números:

1 > x <- 1:15

Creen los siguientes vectores:

JS, YA (DCC - UChile) Prog. Est. en R 11 / 136

Pueden combinar variables y vectores:

JS, YA (DCC - UChile) Prog. Est. en R 12 / 136

1 > e <- c(22, 33, 44, 55)

La función length(x) retorna el largo de un vector:

JS, YA (DCC - UChile) Prog. Est. en R 13 / 136

Aritmética con vectores

Podemos realizar cálculos con vectores:

JS, YA (DCC - UChile) Prog. Est. en R 14 / 136

Creen los siguientes vectores:

JS, YA (DCC - UChile) Prog. Est. en R 15 / 136

R incluye varias funciones que podemos aplicar a variables y vectores:

Formato de funciones: salida <- nombre de funcion(parametros)

JS, YA (DCC - UChile) Prog. Est. en R 16 / 136

1 > x4 <- 1:5

JS, YA (DCC - UChile) Prog. Est. en R 17 / 136

Podemos usar la función seq() para generar secuencias no-triviales de

Ojo: no pueden usar los parámetros by y length al mismo tiempo.

JS, YA (DCC - UChile) Prog. Est. en R 18 / 136

Creen los siguientes vectores:

JS, YA (DCC - UChile) Prog. Est. en R 19 / 136

seq(vector) genera un vector con los valores 1, 2, . . . length(vector):

1 > x <- NULL # vector no definido

Otras maneras de crear un vector vacio:

JS, YA (DCC - UChile) Prog. Est. en R 20 / 136

JS, YA (DCC - UChile) Prog. Est. en R 21 / 136

R reconoce tres valores lógicos:

¿Qué pasa con los NA? lo veremos en la diapo 27 . . .

JS, YA (DCC - UChile) Prog. Est. en R 22 / 136

1 > 31 %% 7 # resto de la division entre dos enteros

TRUE y FALSE toman los valores 1 y 0 en cualquier calculo numérico.

JS, YA (DCC - UChile) Prog. Est. en R 23 / 136

Queremos corregir una prueba de alternativas, donde las respuestas y la

1 > pauta = c(4, 2, 5, 1, 4, 3, 2, 5, 1, 3, 2)

Obtengan el número de respuestas correctas comparando los dos vectores.

JS, YA (DCC - UChile) Prog. Est. en R 24 / 136