Curso basico de R

Francesc Carmona
fcarmona@[Link]
15 de febrero de 2007
El objetivo principal de este curso es proporcionar los elementos basicos para
empezar a trabajar con el lenguaje de programacion R en el ambito de la
Estadstica.
1

Indice
1. Introducci on 7
1.1. R y S . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2. Obtenci on y instalacion de R . . . . . . . . . . . . . . . . 10
1.3. Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4. Documentaci on . . . . . . . . . . . . . . . . . . . . . . . . 12
1.5. Ayudas sobre R . . . . . . . . . . . . . . . . . . . . . . . . 16
2. Empezamos 17
2.1. Inicio de una sesion en R . . . . . . . . . . . . . . . . . . 17
2.2. Una primera sesion . . . . . . . . . . . . . . . . . . . . . . 18
2.3. R como calculadora . . . . . . . . . . . . . . . . . . . . . . 19
2.4. Ayuda dentro del programa . . . . . . . . . . . . . . . . . 20
2.5. Instalacion de paquetes adicionales . . . . . . . . . . . . . 21
2.6. Usar R desde un editor . . . . . . . . . . . . . . . . . . . . 22
2.7. Un ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3. Objetos en R 24
2
3.1. Que objetos? . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2. Tipos de objetos . . . . . . . . . . . . . . . . . . . . . . . 25
3.3. Atributos de los objetos . . . . . . . . . . . . . . . . . . . 28
3.4. Nombres para los objetos . . . . . . . . . . . . . . . . . . 30
3.5. Operaciones aritmeticas . . . . . . . . . . . . . . . . . . . 31
3.6. Operadores l ogicos . . . . . . . . . . . . . . . . . . . . . . 33
3.7. Discretizar datos . . . . . . . . . . . . . . . . . . . . . . . 35
3.8. Operaciones con conjuntos . . . . . . . . . . . . . . . . . 36
4. Vectores 37
4.1. Generaci on de secuencias . . . . . . . . . . . . . . . . . . 37
4.2. Generaci on de secuencias aleatorias . . . . . . . . . . . . 39
4.3. Selecci on de elementos de un vector . . . . . . . . . . . . 40
4.4. Valores perdidos . . . . . . . . . . . . . . . . . . . . . . . . 41
4.5. Ordenacion de vectores . . . . . . . . . . . . . . . . . . . 43
4.6. Vectores de caracteres . . . . . . . . . . . . . . . . . . . . 44
4.7. Factores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5. Arrays y matrices 47
3
5.1. Deniciones . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5.2. Operaciones con matrices . . . . . . . . . . . . . . . . . . 51
5.3. Combinaci on de arrays . . . . . . . . . . . . . . . . . . . . 54
6. [Link] 55
6.1. Denici on . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.2. La familia apply . . . . . . . . . . . . . . . . . . . . . . . . 58
6.3. Tablas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
6.4. Ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7. Muchos objetos 63
7.1. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
7.2. Los objetos que tenemos . . . . . . . . . . . . . . . . . . . 64
7.3. En resumen . . . . . . . . . . . . . . . . . . . . . . . . . . 68
8. Datos 70
8.1. Lectura de datos . . . . . . . . . . . . . . . . . . . . . . . 70
8.2. Guardar y leer datos . . . . . . . . . . . . . . . . . . . . . 71
8.3. Importar datos de Excel . . . . . . . . . . . . . . . . . . . 72
4
8.4. Exportar datos . . . . . . . . . . . . . . . . . . . . . . . . 74
9. Gracos 75
9.1. Introduccion . . . . . . . . . . . . . . . . . . . . . . . . . . 75
9.2. El comando plot . . . . . . . . . . . . . . . . . . . . . . . 76
9.3. Identicaci on interactiva de datos . . . . . . . . . . . . . 80
9.4. Multiples gracos por ventana . . . . . . . . . . . . . . . . 81
9.5. Datos multivariantes . . . . . . . . . . . . . . . . . . . . . 82
9.6. Boxplots . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
9.7. Un poco de ruido . . . . . . . . . . . . . . . . . . . . . . . 84
9.8. Dibujar rectas . . . . . . . . . . . . . . . . . . . . . . . . . 85
9.9. Mas gracos . . . . . . . . . . . . . . . . . . . . . . . . . . 86
9.10. Guardar los gracos . . . . . . . . . . . . . . . . . . . . . 87
10. Funciones 88
10.1. Denici on de funciones . . . . . . . . . . . . . . . . . . . . 88
10.2. Argumentos . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.3. Scope . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
10.4. Control de ejecuci on . . . . . . . . . . . . . . . . . . . . . 92
5
10.5. Cuando algo va mal . . . . . . . . . . . . . . . . . . . . . 95
10.6. Ejecuci on no interactiva . . . . . . . . . . . . . . . . . . . 97
Este curso esta basado muy especialmente en el documento
Introduccion al uso y programaci on del sistema estadstico R
de Ram on Daz-Uriarte de la Unidad de Bioinformatica del CNIO.
6
1. Introducci on
1.1. R y S
R, tambien conocido como GNU S, es un entorno y un lenguaje para
el calculo estadstico y la generaci on de gracos. R implementa un
dialecto del premiado lenguaje S, desarrollado en los Laboratorios Bell
por John Chambers et al.
Para los no iniciados diremos que R provee un acceso relativamente
sencillo a una amplia variedad de tecnicas estadsticas y gracas.
Para los usuarios avanzados se ofrece un lenguaje de programaci on
completo con el que a nadir nuevas tecnicas mediante la denici on de
funciones.
S ha modicado para siempre la forma en la que las personas
analizan, visualizan y manipulan los datos (Association of Computer
Machinery Software System Award 1998 a John Chambers).
7
Actualmente, S y R son los dos lenguajes mas utilizados en
investigaci on en estadstica.
Los grandes atractivos de R/S son:
La capacidad de combinar, sin suras, analisis
preempaquetados(ej., una regresi on logstica) con analisis
ad-hoc, especcos para una situacion: capacidad de manipular y
modicar datos y funciones.
Los gracos de alta calidad: visualizaci on de datos y producci on
de gracos para papers.
La comunidad de R es muy dinamica, con gran crecimiento del
numero de paquetes, e integrada por estadsticos de gran
renombre (ej., J. Chambers, L. Terney, B. Ripley, D. Bates, etc.).
Hay extensiones especcas a nuevas areas como bioinformatica,
geoestadstica y modelos gracos.
Es un lenguaje orientado a objetos.
Se parece a Matlab y a Octave, y su sintaxis recuerda a C/C++.
8
R es la implementaci on GNU de S.
Filosofa y objetivos del proyecto GNU: [Link]
R se distribuye con licencia GNU GPL o General Public
[Link]
La GPL no pone ninguna restriccion al uso de R. Restringe su
distribuci on (ha de ser GPL).
R se obtiene por 0 euros en [Link]
S-PLUS es un programa comercial.
9
1.2. Obtenci on y instalaci on de R
Depende del sistema operativo, pero todo se puede encontrar en
[Link]
Windows: se puede obtener un ejecutable desde
[Link] por ejemplo,
[Link]
Al ejecutar el archivo se instalara el sistema base y los paquetes
recomendados.
GNU/Linux: (dos opciones)
1. Obtener el [Link] y compilar desde las fuentes.
Tambien bajar los paquetes adicionales y instalarlos. (Buena
forma de comprobar que el sistema tiene development tools).
2. Obtener binarios (ej., *.deb para Debian, *.rpm para RedHat,
SuSE, Mandrake).
10
1.3. Paquetes
R consta de un sistema base y de paquetes adicionales que extienden
su funcionalidad.
[Link]
Tipos de paquetes:
Los que forman parte del sistema base (ej. ctest).
Los que no son parte del sistema base, pero son recommended
(ej., survival, nlme).
En GNU/Linux y Windows ya forman parte de la distribuci on
estandar.
Otros paquetes; ej., UsingR, foreing, los paquetes de
Bioconductor (como multtest, etc.).

Estos se han de seleccionar y instalar individualmente. Mas

adelante veremos c omo.
11
1.4. Documentaci on
Los manuales de R, incluidos en todas las instalaciones son:
An introduction to R. (De lectura obligatoria)
Writing R extensions.
R data import/export.
The R language denition.
R installation and administration.
12
Documentaci on general:
R para principiantes, de E. Paradis. En
[Link]
o [Link]
A guide for the unwilling S user, de P. Burns. En
[Link] o
[Link] Solo 8 paginas!
R Graphics, de Paul Murrell.
S Programming, de W. Venables y B. Ripley.
Ver tambien [Link]
13
Estadstica:
simpleR Using R for Introductory Statistics de John Verzani en
[Link]
Introductory statistics with R de P. Dalgaard.
An R and S-PLUS companion to applied regression de J. Fox.
Modern applied statistics with S, 4th ed. de W. Venables y B.
Ripley.
Ver tambien [Link]
Practical regression and ANOVA using R de J. Faraway, en
[Link] o
[Link]
~
faraway/book/.
Estadstica Aplicada con S-PLUS de M. Dolores Ugarte y Ana F.
Militino.
Otros documentos en
[Link]
14
S-PLUS 6.0 for Unix. Guide to statistics. Vol. I & II. En
[Link]
Mixed-eects models in S and S-PLUS de J. Pinheiro y D. Bates.
Regression modelling strategies de F. Harrell.
Modelos Lineales de F. Carmona.
Sitecon documentaci on sobre analisis para datos categoricos
(sitepara el libro de A. Agresti Categorical data analysis).
[Link]
~
aa/cda/[Link]
Modeling survival data: extending the Cox model de T. M.
Therenau y P. M. Grambsch.
Documentos varios en la pagina de J. Fox
[Link]
15
1.5. Ayudas sobre R
Hay diversas formas de ayuda:
Ayuda incluida con el programa (lo veremos mas adelante).
FAQ: [Link]
Rtips de Paul Johnson [Link]
R Help Center [Link]
Las e-mail lists son consultables. Ver
[Link] y
[Link]
Permiten hacer las busquedas no solo sobre las listas de e-mail
sino tambien sobre la documentaci on (incluyendo paquetes).
16
2. Empezamos
2.1. Inicio de una sesi on en R
Windows:
Hacer doble-click en el icono. Se abrira Rgui.
Desde una ventana del sistema ejecutar Rterm o desde
Inicio-Ejecutar...
C:\Archivos de programa\R\R-2.4.1\bin\[Link]
parecido a R en Unix o Linux.
Iniciar R desde Tinn-R, XEmacs o un editor apropiado.
GNU/Linux:
Escribir R en una shell.
Iniciar R desde (X)Emacs (M-X R).
En cualquier caso, se puede adaptar el inicio de una sesion de R (ej.,
que paquetes se cargan, mensajes, etc.). Ver secci on 10.8 en An
introduction to R.
17
2.2. Una primera sesi on
> rnorm(5) # 5 numeros aleatorios de una normal (mean= 0, sd = 1)
> ## "#" indica el principio de un comentario
> ## Los numeros se calculan y se muestran (print)
>
> x <- rnorm(5) # asignamos unos numeros a un objeto (un vector) x
> summary(x) ## muestra un resumen de x (un summary "inteligente")
>
> ## o tambien:
> w <- summary(x)
> w
> print(w) # escribir w y print(w) produce el mismo resultado
>
> ## summary(x) TAMBI

EN es un objeto.
(virtually) everything is an object
18
2.3. R como calculadora
> 2+2
> sqrt(10)
> 2*3*4*5
> # Intereses sobre 1000 euros
> 1000*(1+0.075)^5 - 1000
> # R conoce pi
> pi
> # Circunferencia de la Tierra en el Ecuador en km
> 2*pi*6378
> # Convertimos angulos a radianes y luego calculamos el seno
> sin(c(0,30,45,60,90)*pi/180)
19
2.4. Ayuda dentro del programa
?rnorm
[Link]()
?[Link]
[Link]("normal")
?apropos
apropos("normal")
?demo
demo(graphics); demo(persp); demo([Link])
!Cuidado
> ?if # mal
> help("if")
20
2.5. Instalaci on de paquetes adicionales
Depende del sistema operativo:
Windows:
Desde el men u Packages->Install package(s)...
Primero nos pide seleccionar el CRAN mirror.
Desde R, con [Link]() como en GNU/Linux.
Desde una ventana del sistema o desde Inicio-Ejecutar...
Rcmd INSTALL paquete
Desde la interface de XEmacs.
GNU/Linux:
R CMD INSTALL [Link]
Permite instalar aunque uno no sea root (especicar el dir).
Mas comodo, desde R,
[Link](), [Link](), etc.
Tambien permiten instalar si no eres root (especicar [Link]).
21
2.6. Usar R desde un editor
Por que usar R desde un editor como Tinn-R, R-WinEdt o XEmacs?
El uso de scripts y el mantenimiento del c odigo ordenado y
comentado es una buena practica estadstica (ver tambien
loadhistory, savehistory).
Colores de sintaxis, completa parentesis, etc.
Una interface com un para otros paquetes estadsticos (ej., SAS,
XLispStat, Arc, etc.), numericos (ej., Octave) o procesador de
texto (LaTeX).
Una buena elecci on: Tinn-R.
Tambien WinEdt tiene una conguraci on adaptada: R-WinEdt.
(X)Emacs es MUCHO mas que un editor..., aunque no es muy
conocido para los usuarios de Windows (mejor con las
modicaciones de J. Fox).
22
2.7. Un ejemplo
Sea X una v.a. con distribuci on exponencial de parametro y
X
1
, X
2
, . . . , X
n
una muestra aleatoria simple. Se sabe que la distribuci on
de Z = n mn{X
1
, X
2
, . . . , X
n
} es exponencial de parametro .
> alpha <- 0.01; n <- 50; m <- 1000
> datos <- matrix(rexp(n * m, alpha), ncol=n)
> fz <- function(x) n*min(x)
> z <- apply(datos,1,fz)
> mean(z) # debe ser 1/alpha=100
>
> hist(z,freq=F)
> points(dexp(0:600,alpha),type="l")
>
> [Link](z,"pexp",alpha)
23
3. Objetos en R
3.1. Que objetos?
Casi todo en R es un objeto, incluyendo funciones y estructuras de
datos.
Para saber los objetos que tenemos en el espacio de trabajo
utilizaremos ls().
Escribir el nombre de un objeto muestra su contenido: mean.
Para guardar el contenido del espacio de trabajo se pueden utilizar
las funciones [Link]() y save(<objetos>,file="[Link]")
Para acceder a objetos de la carpeta de trabajo (o del camino que
especiquemos) se pueden adjuntar:
> attach("[Link]")
> ls(pos=2) # segunda posicion en la search list
24
3.2. Tipos de objetos
objetos del lenguaje:
llamadas
expresiones
nombres
expresiones: colecciones de expresiones correctas no evaluadas
funciones:
Constan de
lista de argumentos
c odigo
entorno
sin objeto: NULL
25
Objetos para los datos:
vector: colecci on ordenada de elementos del mismo tipo.
> x <- c(1, 2, 3); y <- c("a", "b", "c")
> z <- c(TRUE, TRUE, FALSE)
array: generalizaci on multidimensional del vector. Elementos del
mismo tipo.
data frame: como el array, pero con columnas de diferentes tipos. Es
el objeto mas habitual para los datos experimentales.
> dades <- [Link](ID=c("gen0", "genB", "genZ"),
+ subj1 = c(10, 25, 33), subj2 = c(NA, 34, 15),
+ oncogen = c(TRUE, TRUE, FALSE),
+ loc = c(1,30, 125))
factor: tipo de vector para datos cualitativos.
> x <- factor(c(1, 2, 2, 1, 1, 2, 1, 2, 1))
26
list: vector generalizado.
Cada lista esta formada por componentes que pueden ser otras
listas. Cada componente puede ser de distinto tipo. Son
contenedores generales de datos. Muy exibles, pero sin
estructura. Muchas funciones devuelven una lista o conjunto de
resultados de distinta longitud y distinto tipo.
> [Link] <- c([Link] = 1:10,
+ [Link] = "hola",
+ [Link] = matrix(rnorm(20), ncol = 5),
+ lista2 = c(a = 5,
+ b = factor(c("a", "b"))))
27
3.3. Atributos de los objetos
Modo: Tipo basico en un vector o array: l ogico, entero, real,
caracter,... mode
Tipo: de los vectores o arrays: double,... typeof
Nombres: etiquetas de los elementos individuales de un vector o lista:
names
Dimensiones: de los arrays (alguna puede ser cero): dim
Dimnames: nombres de las dimensiones de los arrays: dimnames
Clase: vector alfanumerico con la lista de las clases del objeto: class
Otros: atributos de una serie temporal.
28
Ejemplos:
> x <- 1:15; length(x)
> y <- matrix(5, nrow = 3, ncol = 4); dim(y)
> [Link](x); [Link](y); [Link](x)
> x1 <- 1:5; x2 <- c(1, 2, 3, 4, 5); x3 <- "patata"
> typeof(x1); typeof(x2); typeof(x3)
> mode(x); mode(y); z <- c(TRUE, FALSE); mode(z)
> attributes(y)
> w <- list(a = 1:3, b = 5); attributes(w)
> y <- [Link](y); attributes(y)
> f1 <- function(x) {return(2 * x)}
> attributes(f1); [Link](f1)
29
3.4. Nombres para los objetos
Los nombres validos para un objeto son combinaciones de letras,
numeros y el punto (.).
Los nombres no pueden empezar con un n umero.
R es case-sensitive: x != X.
Hay nombres reservados (function, if, etc.).
Otras consideraciones:
El uso del . es distinto del de C++.
Mejor evitar nombres que R usa (ej., c) (se puede arreglar).
> c <- 4; x <- c(3, 8); c
> rm(c); c
Las asignaciones se hacen con "<-" y se recomiendan los
espacios. El signo "=" se reserva para los argumentos de las
funciones.
> x<-1:5 # Estilo incorrecto
> x <- 1:5 # Mucho mejor
30
3.5. Operaciones aritmeticas
Las operaciones con vectores mejoran el uso de bucles.
Todo mas claro:
Es la forma natural de operar sobre objetos completos.
C odigo mas facil de entender.
Mas sencillo de modicar y mantener.
Mas facil de hacer debugging.
Mas rapido de escribir.
Mas eciente (en tiempo y memoria).
31
Principales operaciones aritmeticas:
suma +, resta -, multiplicaci on *, divisi on /
potencia ^, raz cuadrada sqrt
%/% divisi on entera, %% modulo: resto de la divisi on entera
logaritmos log, log10, log2, logb(x, base), exponencial exp
trigonometricas sin, cos, tan, asin, acos, atan
otras:
max, min, range, pmax, pmin, mean, median, var, sd, quantile
sum, prod, diff cumsum, cumprod, cummax, cummin
Ejemplo:
> data(presidents)
> help(presidents)
> range(presidents, [Link] = TRUE)
> [Link](presidents)# 28
> [Link](presidents)# 2
32
3.6. Operadores l ogicos
<, >, <=, >=, ==, !=
!, &, |, xor() y los parecidos &&, ||
> x <- 5; x < 5; x >= 5; x == 6; x != 5
> y <- c(TRUE, FALSE); !y; z <- c(TRUE, TRUE)
> xor(y, z)
> y & z; y | z
Las formas &&, || se eval uan de izquierda a derecha, examinando
solo el primer elemento de cada vector (si decide). Se suelen usar
dentro de instrucciones if.
if ([Link](x) && min(x) > 0) {entonces...
min(x) no tiene sentido si x no es numerico.
0 + y; [Link](y); mode(y) <- "numeric"
33
Ejemplo:
> peso <- c(19,14,15,17,20,23,30,19,25)
> peso < 20
> peso < 20 | peso > 25
> peso[peso<20]
> peso[peso<20 & peso!=15]
> trat <- c(rep("A",3),rep("B",3),rep("C",3))
> peso[trat=="A"]
> peso[trat=="A"|trat=="B"]
> split(peso,trat)
> split(peso,trat)$A
34
3.7. Discretizar datos
La funci on split(x,f)
> split(peso,trat)
> split(peso,trat)$A
La funci on cut
> vv <- rnorm(100)
> cut1 <- cut(vv, 5)
> table(cut1)
>
> cut2 <- cut(vv, quantile(vv, c(0, 1/4, 1/2, 3/4, 1)))
> summary(cut2)
> class(cut2)
35
3.8. Operaciones con conjuntos
> x <- 1:5; y <- c(1, 3, 7:10)
> union(x, y)
> intersect(x, y)
> setdiff(y, x)
> v <- c("bcA1", "bcA2", "blX1")
> w <- c("bcA2", "xA3")
> union(v, w)
> intersect(v, w)
> setdiff(w, v)
> setdiff(v, w)
36
4. Vectores
4.1. Generaci on de secuencias
> x <- c(1, 2, 3, 4, 5)
> x <- 1:10; y <- -5:3
> 1:4+1; 1:(4+1)
> x <- seq(from = 2, to = 18, by = 2)
> x <- seq(from = 2, to = 18, length = 30)
> y <- seq(along = x)
> z2 <- c(1:5, 7:10, seq(from=-7,to=5,by=2))
37
> rep(1, 5)
> x <- 1:3; rep(x, 2)
> y <- rep(5, 3); rep(x, y)
> rep(1:3, rep(5, 3))
> rep(x, x)
> rep(x, length = 8)
> gl(3, 5) # como rep(1:3, rep(5, 3))
> gl(4, 1, length = 20) # !Alerta! gl genera factores
> gl(3, 4, label = c("Sano", "Enfermo", "Muerto"))
> [Link](edad = c(10, 18, 25),
> sexo = c("Macho", "Hembra"), loc = 1:3)
Podemos combinar: z5 <- c(1:5, rep(8, 3))
38
4.2. Generaci on de secuencias aleatorias
> sample(5)
> sample(5, 3)
> x <- 1:10
> sample(x)
> sample(x, replace = TRUE)
> sample(x, length = 2* length(x), replace = TRUE)
> probs <- x/sum(x)
> sample(x, prob = probs)
N umeros aleatorios rDistribucion(n,parametros)
> rnorm(10) # rnorm(10, mean = 0,sd = 1)
> runif(8,min=2,max=10)
39
4.3. Selecci on de elementos de un vector
> x <- 1:5; x[1]; x[3]; x[c(1,3)]
> x[x > 3]
> x > 3
> y <- x > 3
> x[y]
> x[-c(1, 4)]; y <- c(1, 2, 5); x[y]
> names(x) <- c("a", "b", "c", "d", "patata")
> x[c("b", "patata")]
40
4.4. Valores perdidos
NA es el c odigo de Not available.
> v <- c(1,6,9,NA)
> [Link](v); which([Link](v))
> w <- v[] # sin los valores perdidos
> v == NA # !No funciona! Por que?
Sustituir NA por, [Link]., 0:
> v[[Link](v)] <- 0
El innito y NaN (not a number) son diferentes de NA.
> 5/0; -5/0; 0/0
> [Link](-5/0); [Link](0/0); [Link](5/0)
Con algunas funciones
> xna <- c(1, 2, 3, NA, 4); mean(xna)
> mean(xna, [Link] = TRUE)
41
Para modelling functions (ej. lm) lo mejor es usar
[Link]
[Link]
Esta ultima es mas conveniente para generar predicciones,
residuos, etc.
Eliminar todos los NA:
> XNA <- matrix(c(1,2,NA,3,NA,4), nrow = 3)
> XNA
> [Link] <- [Link](XNA)
42
4.5. Ordenaci on de vectores
> x1 <- c(5, 1, 8, 3)
> order(x1)
> sort(x1)
> rev(x1)
> rank(x1)
> x1[order(x1)]
> x2 <- c(1, 2, 2, 3, 3, 4); rank(x2)
> min(x1); [Link](x1); which(x1 == min(x1))
> y <- c(1, 1, 2, 2); order(y, x)
order y sort admiten decreasing = TRUE.
43
4.6. Vectores de caracteres
> codigos <- paste(c("A", "B"), 2:3, sep = "")
> codigos <- paste(c("A", "B"), 2:3, sep = ".")
> juntar <-
paste(c("una", "frase", "simple"), collapse =" ")
> columna.a <- LETTERS[1:5]; columna.b <- 10:15
> juntar <- paste(columna.a, columna.b, sep ="")
> substr("abcdef",2,4)
> x <- paste(LETTERS[1:5], collapse="")
> substr(x, 3, 5) <- c("uv")
Otras funciones de manipulaci on de caracteres:
nchar, grep, match, pmatch, tolower,
toupper, sub, gsub, regexpr.
44
4.7. Factores
Consideremos el c odigo postal:
> [Link] <- c(28430, 28016, 28034);
> mode([Link])
No deberamos usar el codigo postal en, por ejemplo, un ANOVA
como si fuera un vector numerico. Usar variables aparentemente
numericas en analisis estadsticos es un grave error.
> [Link] <- factor([Link]) # mejor
Antes de utilizar un vector con caracteres dentro de un analisis,
hace falta convertirlo en un factor. En caso contrario, R protesta.
> y <- rnorm(10); x <- rep(letters[1:5], 2)
> aov(y ~ x) # !error!
> aov(y ~ factor(x)) # funciona
45
Si queremos convertir un vector factor en numerico:
> x <- c(34, 89, 1000); y <- factor(x); y
> [Link](y) # mal
> # los valores han sido recodificados
> [Link]([Link](y)) # bien
Podemos jar el orden de las etiquetas:
> ftr1 <- factor(c("alto", "bajo", "medio"))
> ftr1
> ftr1 <- factor(c("alto", "bajo", "medio"),
+ levels = c("bajo", "medio", "alto"))
46
5. Arrays y matrices
5.1. Deniciones
Un array es una colecci on de datos del mismo tipo con varias
dimensiones.
> a <- 1:24; dim(a) <- c(3,4,2)
El vector a pasa a ser un array 3x4x2.
Una matrix es un array con dos dimensiones. Tienen una
funcionalidad muy parecida, pero matrix es mas comoda.
> a1 <- array(9, dim = c(5,4))
> a2 <- matrix(1:20, nrow = 5)# como en FORTRAN
> a3 <- matrix(1:20, nrow = 5, byrow = TRUE)
> a4 <- 1:20; dim(a4) <- c(5, 4)
47
Con las coordenadas se obtienen los elementos particulares, como
en los vectores:
> a[1,1,1]; a[1,1,2]; a[3,4,2]
Tambien podemos considerar subconjuntos de un array
> a[2, , ] # es un array de dimension c(4,2)
> a4[1, ]; a4[, 2]; a4[c(1, 3), c(2, 4)]
Tambien se pueden dar las coordenadas matricialmente. Observar
el ejemplo:
> im <- matrix(c(1, 3, 2, 4), nrow = 2)
> im
> a4[im]
48
Ejemplo:
> x <- c(190,8,22,191,4,1.7,223,80,2,210,50,3)
> datos <- matrix(x,nrow=4,byrow=T); dim(datos)
> ciudades <- c("Barna","Tarraco","Lleida","Gi")
> dimnames(datos) <- list(ciudades,NULL)
> variables <- c("A","B","C")
> dimnames(datos) <- list(ciudades,variables)
> datos
> dimnames(datos)
> datos["Barna", ]
> datos[ ,"C"]
49
Otro ejemplo:
> a4 <- 1:20; dim(a4) <- c(5, 4)
> attributes(a4)
> colnames(a4) <- paste("v", 1:4, sep = "")
> rownames(a4) <- paste("id", 1:5, sep = ".")
> a4[, c("v1", "v3")]
> attributes(a4)
Para ordenar un array por una columna:
> matriz <- matrix(rnorm(20),ncol=4)
> [Link] <- matriz[order(matriz[, 1]), ]
50
5.2. Operaciones con matrices
A %*% B : producto de matrices
t(A) : transpuesta de la matriz A
solve(A,b) : soluci on del sistema de ecuaciones Ax=b.
solve(A) : inversa de la matriz A
svd(A) : descomposici on en valores singulares
qr(A) : descomposici on QR
eigen(A) : valores y vectores propios
diag(b) : matriz diagonal (b es un vector)
diag(A) : matriz diagonal (A es una matriz)
A %o% B == outer(A,B) : producto exterior de dos vectores o
matrices
51
Las funciones var, cov y cor calculan la varianza de x y la
covarianza o correlaci on de x y y si estos son vectores. Cuando x y
y son matrices, entonces calculan las covarianzas (o correlaciones)
entre las columnas de x y las columnas de y.
> data(longley)
> (Cl <- cor(longley))
> ## Graphical Correlation Matrix:
> symnum(Cl) # highly correlated
> ## Spearmans rho
> cor(apply(longley, 2, rank))
> cor(longley, method = "spearman") # better
La funci on cov2cor convierte ecientemente una matriz de
covarianzas en la correspondiente matriz de correlaciones.
52
La funci on outer(X, Y, FUN="*", ...) proporciona por defecto el
producto exterior de los dos arrays. Sin embargo, podemos
introducir otras funciones e incluso nuestras propias funciones.
> x <- 1:9; names(x) <- x
> # Multiplication & Power Tables
> x %o% x
> y <- 2:8; names(y) <- paste(y,":",sep="")
> outer(y, x, "^")
53
5.3. Combinaci on de arrays
Para combinar vectores, matrices o arrays utilizamos las instrucciones
rbind y cbind.
> x1 <- 1:10; x2 <- 11:20
> a6 <- diag(6) # matriz identidad
> a7 <- cbind(x1, x2); a8 <- rbind(x1, x2)
> a24 <- cbind(a2, a4)
> cbind(a4, a6) # no funciona
> rbind(a4, a6) # no funciona
> a9 <- matrix(rnorm(30), nrow = 5)
> cbind(a4, a9)
> rbind(a4, a9) # no funciona
54
6. [Link]
6.1. Denici on
Para datos de diferentes tipos:
> x3 <- letters[1:10]
> a9 <- cbind(x1, x2, x3)
De que tipo es a9? Es eso lo que queramos?
Mejor con un [Link]:
> a10 <- [Link](x1, x2, x3)
> prcomp(a10[, c(1,2)])# comp. principales
> prcomp(a10[, c("x1", "x2")])
> prcomp(a10[, -3])
55
Tambien podemos a nadir alguna columna a una matriz como
datos:
> playa <- c("si","si","no","no")
> [Link] <- [Link](datos,playa)
> [Link]$playa
Usar $ facilita el acceso y la creaci on de nuevas columnas:
> [Link](1) # fija la semilla del random number generator
> d1 <- [Link](g1 = runif(10), g2 = rnorm(10))
> d1$edad <- c(rep(20, 5), rep(40, 5))
> [Link](1)
> d2 <- cbind(g1 = runif(10), g2 = rnorm(10))
> d2[, 3] <- c(rep(20, 5), rep(40, 5)) # error
> d2 <- cbind(d2, edad = c(rep(20, 5), rep(40, 5)))
56
Ademas, en los [Link] los character vectors se convierten
en factores.
Podemos convertir matrices a [Link] con [Link]().
Los [Link] tambien tienen rownames, colnames.
> attributes(a10) # cuando no estan definidos
Tambien podemos usar dimnames(a10).
57
6.2. La familia apply
> ax <- matrix(rnorm(20), ncol = 5)
> [Link] <- apply(ax, 1, mean)
> [Link] <- apply(ax, 1, mean, [Link] = TRUE)
> mi.f1 <- function(x) { return(2*x - 25)}
> [Link] <- apply(ax, 1, mi.f1)
> [Link] <- apply(ax, 1, function(x){return(2*x -25)})
> [Link] <- apply(ax, 2, mean)
> [Link] <- apply(ax, 1, sample)
> [Link] <- function(y){return(c(mean(y), var(y)))}
> apply(ax, 1, [Link])
> t(apply(ax, 1, [Link]))
58
Utilizar apply es generalmente mucho mas eciente que un bucle.
Ademas de mas claro, mas facil, etc..
> parameters <- cbind(mean = -5:5, sd = 2:12)
> [Link] <- matrix(rnorm(1000 * 11), nrow = 11)
> data <- ([Link] * parameters[,2]) + parameters[,1]
> apply(data, 1, mean); apply(data, 1, sd)
Las funciones sapply(X,funcion) y lapply(X,funcion) son como
apply(x,i,funcion) pero no hay que especicar el ndice i=2;
sapply intenta simplicar el resultado a un vector o a una matriz
(la s es de simplify), pero lapply siempre devuelve una lista.
Ambas pueden aplicarse a vectores, listas, arrays.
> data(airquality)
> sapply(airquality, function(x)sum([Link](x)))
59
La funci on tapply(x,y,funcion) calcula la funci on especicada
sobre el objeto x seg un las categoras de y.
> x <- c(19,14,15,17,20,23,19,19,21,18)
> trat <- c(rep("A",5),rep("B",5))
> [Link] <- tapply(x,trat,mean)
> [Link]
apply, sapply, lapply y tapply son funciones muy utiles que
contribuyen a hacer el c odigo mas legible, facil de entender, y
facilitan posteriores modicaciones y aplicaciones.
Consejo: Cada vez que vayamos a usar un loop intentemos
substituirlo por alg un miembro de familia apply.
Algunas funciones hacen un apply:
> x1 <- 1:10
> m1 <- matrix(1:20, ncol = 5)
> d1 <- [Link](m1)
> mean(x1); mean(d1); sd(x1); sd(d1); median(m1); median(d1)
60
6.3. Tablas
La tabulacion cruzada de dos variables cualitativas se consigue
con la funci on table.
> table(sexo,nivel)
Para introducir una tabla de contingencia tambien se utiliza la
instrucci on table. Las variables se denen con sus modalidades
con la instrucci on [Link](var1,var2).
> resultado <- cbind([Link](
+ calif=c("mejor","peor","igual"),
+ tratam=c("A","B")))
> frec <- c(21,34,5,7,12,14)
> tabla <- table(calif,tratam)*frec
> tabla
61
6.4. Ejemplo
> d3 <- [Link](g1=runif(10),g2=rnorm(10),
+ id1 = c(rep("a", 3), rep("b", 2),
+ rep("c", 2), rep("d", 3)))
> [Link] <- function(x) {
+ [Link] <- mean(x[, -3])
+ [Link] <- var(x[, -3])
+ [Link] <- max(x[, -3])
+ [Link] <- table(x[, 3])
+ return(list([Link] = [Link],
+ [Link] = [Link], maximum = [Link],
+ [Link] = [Link]))
+ }
> [Link](d3)
62
7. Muchos objetos
7.1. Listas
> [Link] <- [Link](d3); [Link]
> attributes([Link]); names([Link])
> length([Link])
> [Link][[4]]
> [Link][4] # por que sale el nombre? class
> [Link]$[Link]
> [Link][[3]] <- list(NULL); [Link]
> [Link][[3]] <- NULL
> [Link] # hemos eliminado el "slot" maximum
> unlist([Link])
> [Link] <- list(cucu = 25, [Link])
> unlist([Link])
> unlist([Link], drop = FALSE)
> [Link] <- c([Link], [Link] = "una frase")
63
7.2. Los objetos que tenemos
Para saber los objetos que hemos denido hacemos
> ls()
> objects()
> objects(pattern="a*")
R tiene una lista donde buscar los objetos accesibles: the search
list. Cargar un paquete extiende la search list.
Para obtener la lista de los directorios, llamados databases:
> search()
> library(MASS)
> search()
64
Para que un objeto o directorio sea facilmente accesible lo
podemos poner en la search list de R. En el caso de un
[Link], esto permite acceder directamente a las columnas por
su nombre.
> str([Link]) # es un [Link]
> A # error
> attach([Link])
> A # ahora s
> plot(A,B) # en lugar de plot([Link]$A,[Link]$B)
La actualizacion no es dinamica
> [Link]$D <- 1:4 # una nueva columna
> [Link] # aqu esta
> D # pero aqu no
Para desconectar
> detach(objeto)
65
Para borrar objetos concretos
> rm(objetos)
Para borrar todos los objetos del entorno de trabajo:
> rm(list = ls())
Para cargar un archivo [Link] con objetos diversos (datos,
funciones,...) se puede hacer un attach o un load. La primera
instrucci on accede a los objetos cuando se requieren, la segunda
los carga todos.
> load("[Link]")
66
Alerta!
> [Link]
> A <- 1
> A # usa la ultima
> search() # el search path
> detach([Link])
> attach([Link])
> D
> A # cuidado
Conclusi on: En entornos confusos, como un analisis que se
prolonga dos semanas, es mejor evitar attach y acceder siempre a
las variables usando su localizacion explcita y completa.
67
7.3. En resumen
La manipulacion de datos en R es muy exible.
Podemos seleccionar variables, casos, subsecciones de datos, etc,
de acuerdo con criterios arbitrarios (que usan, ademas, condiciones
que pueden implicar a un n umero arbitrario de variables y casos).
Los [Link] y las matrices pueden separarse, juntarse,
cambiarse de forma (reshape), etc.
El indexado y selecci on de casos pueden usar n umeros, factores,
cadenas de caracteres, etc.
Podemos preparar c odigo que repita las mismas operaciones con
datos semejantes (i.e., podemos automatizar el proceso con
sencillez).
Podemos vericar al vuelo que estas transformaciones hacen lo
que queremos que hagan (mirando selectivamente los resultados,
o emulando el proceso en unos datos articiales mas peque nos).
Por tanto, una vez que los datos estan en R, no hay muchas
68
razones para exportarlos y hacer la selecci on y manipulaci on con
otros lenguajes (ej., Python, Perl) para luego volver a leerlos en R.
69
8. Datos
8.1. Lectura de datos
Para leer un chero simple, con los datos separados por espacios
en blanco, tabuladores o saltos de lnea, se utiliza la instrucci on
[Link] en la forma:
> [Link] <- [Link]("c:/dir/[Link]",
+ header = TRUE, sep = "",
+ [Link] = "")
Si el caracter decimal no es un punto sino, por ej., una coma,
usar: dec = ",".
Se pueden saltar lneas (skip) o leer un numero jo de lneas
(nrows).
Hay funciones especializadas para otros archivos (ej., [Link])
pero son casos especcos de [Link].
70
8.2. Guardar y leer datos
Resulta muy importante poder guardar datos, funciones, etc., para
ser usados en otras sesiones de R. Esos datos as guardados
pueden compartirse con otros usuarios e incluso utilizarse en
distintos sistemas operativos.
> x <- runif(20)
> y <- list(a = 1, b = TRUE, c = "patata")
> save(x, y, file = "[Link]")
Los leeremos con
> load("[Link]")
71
Podemos guardar todos los objetos con
> [Link]() # guardado como ".RData"
> [Link](file = "[Link]")
El chero .RData se carga al iniciarse R.
R y muchos otros paquetes incorporan archivos con datos:
Se cargan con load("[Link]").
La instruccion data permite cargar archivos de las libreras
disponibles.
> data() # muestra todos los archivos
> data(iris)
> data(iris, package = "base") # equivalente
> ?iris
72
8.3. Importar datos de Excel
Lo mejor es exportar los datos desde Excel a un archivo de texto
separado por tabuladores.
Cuidado con las ultimas columnas y missing data (Excel elimina
los trailing tabs). Dos formas de minimizar problemas:
Usar NA para missing.
Poner una ultima columna con datos arbitrarios (ej., una
columna llena de 2s).
Cuidado tambien con lneas extra al nal del chero.
Salvamos como texto (solo salvamos una de las hojas).
Importamos en R con [Link].
73
8.4. Exportar datos
Lo mas sencillo es exportar una matriz
(es necesario transponer la matriz).
> write(t(x), file = "c:/dir/[Link]",
+ ncolumns = n,
+ append = FALSE)
Pero para exportar un [Link] es mejor
> [Link]([Link],
+ file = "[Link]",
+ sep = "",[Link] = FALSE,
+ [Link] = TRUE)
Para escribir un chero CSV importable desde Excel
> [Link](x, file = "[Link]", sep = ",",
+ [Link] = NA)
74
9. Gracos
9.1. Introducci on
R incluye muchas y variadas funciones para hacer gracos.
El sistema permite desde gracos muy simples a guras de calidad
para incluir en artculos y libros.
Solo examinaremos la supercie. Mas detalles en el libro R
Graphics de Paul Murrell.
Tambien podemos ver un buen conjunto de ejemplos con
demo(graphics).
El comando plot es uno de los mas utilizados para realizar
gracos.
75
9.2. El comando plot
Si escribimos plot(x, y) donde x e y son vectores con n
coordenadas, entonces R representa el graco de dispersion con
los puntos de coordenadas (x
i
, y
i
).
Este comando incluye por defecto una elecci on automatica de
ejes, escalas, etiquetas de los ejes, densidad de las lneas, etc., que
pueden ser modicados a nadiendo parametros gracos al
comando y que pueden visualizarse con help(par).
> x <- runif(50, 0, 4); y <- runif(50, 0, 4)
> plot(x, y, main = "Ttulo principal",
+ sub = "subttulo", xlab = "eje x", ylab = "eje y",
+ xlim = c(-5,5),ylim = c (-5,5))
76
Variaciones de plot:
> z <- cbind(x,y)
> plot(z)
> plot(y ~ x)
> plot(log(y + 1) ~ x) # transformacion de y
> plot(x, y, type = "p")
> plot(x, y, type = "l")
> plot(x, y, type = "b")
> plot(c(1,5), c(1,5))
> legend(1, 4, c("uno", "dos", "tres"), lty = 1:3,
+ col = c("red", "blue", "green"),
+ pch = 15:17, cex = 2)
Con text podemos representar caracteres de texto directamente:
> sexo <- c(rep("v", 20), rep("m", 30))
> plot(x, y, type = "n")
> text(x, y, labels = sexo)
77
Puntos.
> points(x, y, pch = 3, col = "red")
Tipos de puntos.
> plot(c(1, 10), c(1, 3), type = "n", axes = FALSE,
+ xlab = "", ylab="")
> points(1:10, rep(1, 10), pch = 1:10, cex = 2, col = "blue")
> points(1:10, rep(2, 10), pch = 11:20, cex = 2, col = "red")
> points(1:10, rep(3, 10), pch = 21:30, cex = 2,
+ col = "blue", bg = "yellow")
Tipos de lneas.
> plot(c(0, 10), c(0, 10), type = "n", xlab ="",
+ ylab ="")
> for(i in 1:10)
+ abline(0, i/5, lty = i, lwd = 2)
> for(i in 1:10)
+ abline(0, i/5, lty = i, lwd = 2)
78
lty permite especicaciones mas complejas (longitud de los
segmentos que son alternativamente dibujados y no dibujados).
par controla muchos parametros gracos. Por ejemplo, cex puede
referirse a los labels ([Link]), otro, [Link], a la anotaci on de
los ejes, etc.
Hay muchos mas colores. Ver palette, colors.
79
9.3. Identicaci on interactiva de datos
identify(x, y, etiquetas) identica los puntos con el rat on y escribe
la correspondiente etiqueta.
> x <- 1:10
> y <- sample(1:10)
> nombres <- paste("punto", x, ".", y, sep ="")
> plot(x, y)
> identify(x, y, labels = nombres)
locator() devuelve las coordenadas de los puntos.
> plot(x, y)
> locator()
> text(locator(1), "el marcado", adj = 0)
80
9.4. Multiples gracos por ventana
Empezamos con par(mfrow=c(las,columnas)) antes del comando
plot.
> par(mfrow = c(2, 2))
> plot(rnorm(10))
> plot(runif(5), rnorm(5))
> plot(runif(10))
> plot(rnorm(10), rnorm(10))
Podemos mostrar muchos gracos en el mismo dispositivo graco.
La funci on mas exible y sosticada es [Link], bien
explicada en R para principiantes, secc. 4.1.2 (p. 30).
81
9.5. Datos multivariantes
Diagrama de dispersion multiple.
> X <- matrix(rnorm(1000), ncol = 5)
> colnames(X) <- c("a", "id", "edad", "loc",
+ "weight")
> pairs(X)
Gracos condicionados (revelan interacciones).
> Y <- [Link](X)
> Y$sexo <- [Link](c(rep("Macho", 80),
+ rep("Hembra", 120)))
> coplot(weight ~ edad | sexo, data = Y)
> coplot(weight ~ edad | loc, data = Y)
> coplot(weight ~ edad | loc * sexo, data = Y)
La librera lattice permite lo mismo, y mucho mas, que coplot.
Ver secc. 4.6 de R para principiantes.
82
9.6. Boxplots
Los diagramas de caja son muy utiles para ver rapidamente las
principales caractersticas de una variable cuantitativa, o comparar
entre variables.
> attach(Y)
> boxplot(weight)
> plot(sexo, weight)
> detach()
> boxplot(weight ~ sexo, data = Y,
+ col = c("red", "blue"))
La funci on boxplot tiene muchas opciones; se puede modicar el
aspecto, mostrarlos horizontalmente, en una matriz de boxplots,
etc. Vease la ayuda ?boxplot.
83
9.7. Un poco de ruido
Los datos cuantitativos discretos pueden ser difciles de ver bien.
Podemos a nadir un poco de ruido con el comando jitter.
> dc1 <- sample(1:5, 500, replace = TRUE)
> dc2 <- dc1 + sample(-2:2, 500, replace = TRUE,
+ prob = c(1, 2, 3, 2, 1)/9)
> plot(dc1, dc2)
> plot(jitter(dc1), jitter(dc2))
84
9.8. Dibujar rectas
Podemos a nadir muchos elementos a un graco, ademas de
leyendas y lneas rectas.
> x <- rnorm(50)
> y <- rnorm(50)
> plot(x, y)
> lines(lowess(x, y), lty = 2)
> plot(x, y)
> abline(lm(y ~ x), lty = 3)
Podemos a nadir otros elementos con panel functions en otras
funciones (como pairs, lattice, etc).
85
9.9. Mas gracos
Podemos modicar margenes exteriores de guras y entre guras
(vease ?par y b usquense oma, omi, mar, mai; ejemplos en An
introduction to R, secc. 12.5.3 y 12.5.4.
Tambien gracos 3D: persp, image, contour; histogramas: hist;
gracos de barras: barplot; gracos de comparaci on de cuantiles,
usados para comparar la distribuci on de dos variables, o la
disribuci on de unos datos frente a un estandar (ej., distribuci on
normal): qqplot, qqnorm y, en paquete car, [Link].
Notaci on matematica (plotmath) y expresiones de texto
arbitrariamente complejas.
Gracos tridimensionales dinamicos con XGobi y GGobi. Ver:
[Link]
[Link]
[Link]
~
ray/R-stuff/windows/[Link].
86
9.10. Guardar los gracos
En Windows, podemos usar los menus y guardar con distintos
formatos.
Tambien podemos especicar donde queremos guardar el graco.
> pdf(file = "[Link]", width = 8, height = 10)
> plot(rnorm(10))
> [Link]()
O bien, podemos copiar una gura a un chero.
> plot(runif(50))
> dev.copy2eps()
87
10. Funciones
10.1. Denici on de funciones
R es un lenguaje que permite crear nuevas funciones. Una funci on
se dene con una asignacion de la forma
> nombre <- function(arg1,arg2,...){expresion}
La expresi on es una f ormula o grupo de f ormulas que utilizan los
argumentos para calcular su valor. El valor de dicha expresi on es el
valor que proporciona R en su salida y este puede ser un simple
numero, un vector, una graca, una lista o un mensaje.
Ejemplo: Suma de una progresi on aritmetica
> suma <- function(a1,d,n){
+ an <- a1+(n-1)*d;
+ ((a1+an)*n)/2}
88
10.2. Argumentos
Una funci on con cuatro argumentos
> una.f <- function(a,b,c = 4,d = FALSE){x1<-a*z ...}
Los argumentos a y b tienen que darse en el orden debido o, si los
nombramos, podemos darlos en cualquier orden:
> una.f(4, 5)
> una.f(b = 5, a = 4)
Pero los argumentos con nombre siempre se tienen que dar
despues de los posicionales:
> una.f(c = 25, 4, 5) # error
Los argumentos c y d tienen valores por defecto. Podemos
especicarlos nosotros o no (i.e., usar los valores por defecto).
89
args([Link]) nos muestra los argumentos de cualquier
funci on.
... permite pasar argumentos a otra funci on:
> f3 <- function(x, y, label = "la x", ...){
+ plot(x, y, xlab = label, ...)}
>
> f3(1:5, 1:5)
> f3(1:5, 1:5, col = "red")
Para realizar funciones de dos variables se puede utilizar el
comando outer. Por ejemplo:
> f <- function(x,y){cos(y)/(x^2-3)}
> z <- outer(x,y,f)
90
10.3. Scope
En la funci on una.f z es una free variable: c omo se
especica su valor? Lexical scoping. Ver documento Frames,
environments and scope in R and S-PLUS de J. Fox en
[Link]
y secci on 10.7 en An introduction to R. Tambien ver
demo(scoping).
Un ejemplo
> cubo <- function(n) {
+ sq <- function() n*n # aqu n no es un argumento
+ n*sq()
+ }
En esto R (lexical scope) y S-PLUS (static scope) son distintos.
91
10.4. Control de ejecuci on
Principales instrucciones
if(cond) expr
if(cond) [Link] else [Link]
for(var in seq) expr
while(cond) expr
repeat expr
break
next
La expresi on expr (tambien [Link]) puede ser una expresi on
simple o una de las llamadas expresiones compuestas,
normalmente del tipo {expr1; expr2}.
Uno de los errores mas habituales es el olvido de los corchetes
{...} alrededor de las instrucciones, i.e. despues de if(...) o
for(...).
92
if ([Link]) instrucci on else instrucci [Link]
> f4 <- function(x) {
+ if(x > 5) print("x > 5")
+ else {
+ y <- runif(1)
+ print(paste("y is ", y))
+ }
+ }
ifelse es una versi on vectorizada (Thomas Unternahrer, R-help,
2003-04-17)
> [Link] <- function(x) {
+ ifelse(x %% 2 == 1, "Odd", "Even")
+ }
> mtf <- matrix(c(TRUE, FALSE, TRUE, TRUE),
+ nrow = 2)
> ifelse(mtf, 0, 1)
93
for ([Link] in valores) instrucci on
> for(i in 1:10) cat("el valor de i es", i, "\n")
> [Link] <- TRUE
> x <- 0
> while([Link]) {
+ x <- x + 1
+ print(x)
+ if( x > 10) [Link] <- FALSE
+ }
break para salir de un loop.
94
10.5. Cuando algo va mal
Cuando se produce un error, traceback() nos informa de la
secuencia de llamadas antes del crash de nuestra funci on. Es
util cuando se producen mensajes de error incomprensibles.
Cuando se producen errores o la funci on da resultados incorrectos
o warnings indebidos podemos seguir la ejecuci on de la funci on.
browser interrumpe la ejecuci on a partir de ese punto y permite
seguir la ejecuci on o examinar el entorno; con n paso a paso, si
otra tecla sigue la ejecuci on normal. Q para salir.
debug es como poner un broswer al principio de la funci on y se
ejecuta la funci on paso a paso. Se sale con Q.
> debug([Link])
> ...
> undebug([Link])
95
Ejemplo:
> my.f2 <- function(x, y) {
+ z <- rnorm(10) + y2 <- z * y + y3 <- z * y * x + return(y3 + 25)
+ }
> my.f2(runif(3), 1:4)
> debug(my.f2)
> my.f2(runif(3), 1:4)
> undebug(my.f2)
> # insertar un browser() y correr de nuevo
96
10.6. Ejecuci on no interactiva
Con source abrimos una sesi on de R y hacemos
> source("[Link].R")
Con BATCH:
Rcmd BATCH [Link].R
source es en ocasiones mas util porque informa inmediatamente de
errores en el c odigo. BATCH no informa, pero no requiere tener
abierta una sesion (se puede correr en el background).
Ver la ayuda: Rcmd BATCH --help
Puede que necesitemos explcitos print statements o hacer
source([Link].R, echo = TRUE).
sink es el inverso de source (lo manda todo a un chero).
Se pueden crear paquetes, con nuestras funciones, que se
comporten igual que los demas paquetes. Ver Writing R
extensions.
97
R puede llamar c odigo compilado en C/C++ y FORTRAN. Ver
.C, .Call, .Fortran.
Lexical scoping importante en programaci on mas avanzada.
No hemos mencionado el computing on the language (ej.,
[Link], eval, etc.).
R es un verdadero object-oriented language. Dos
implementaciones, las S3 classes y las S4 classes.
98