Introducción a R

En primer lugar veamos algunas de las cosas que podemos hacer con R:

  1. Crear cuestionarios interactivos, con ayuda del paquete o librería "slidify".

  2. Crear presentaciones interactivas espectaculares, con ayuda del paquete "slidify" y "impressjs".

  3. Crear gráficos dinámicos con ayuda del paquete R googleVis.

  4. Podemos escribir reports o documentos de análisis estadístico con ayuda de R, Markdown y RStudio

  5. Uno de los entornos de trabajo más novedosos y completos para trabajar con R RStudio. La versión RStudio beta.

  6. Podemos crear aplicación web con la ayuda de Shiny, más ejemplos.

  7. Compartir estadística con otros usuarios a nivel mundial a través de RPubs.

  8. También se puede editar código R y report directamente en la web, al estilo de un bloc de notas rNotebook.

  9. Gráficos espectaculares con ggplot2.

  10. Algunas más: knitrBootstrap.

¿Qué es R?

  1. Un lenguaje y un entorno para el cálculo estadístico y gráfico.

  2. Lenguaje elaborado por estadísticos para estadísticos.

  3. Y es GRATUITO.

  4. Puede importar y exportar casi todos los formatos de datos conocidos (spss, sas, mysql, ...).

  5. Comunidad enorme de usuarios y que sigue en aumento. Cada vez más se demandan puestos de trabajo relacionados con R.

  6. Hay paquetes o librerías desarrolladas para resolver problemas de muchos ámbitos o áreas científicas.

Los creadores de R (Chambers, Ihaka, Robert):

Chambers Ihaka Robert

La página principal de R, dónde puede encontrarse todo el material referente a él es: http://cran.r-project.org.

Podemos descargar el programa R, el cual está disponible para los tres sistemas operativos más conocidos: Windows, Linux y Mac.

Realizando cálculos y representaciones gráficas

A continuación podemos ver código R y los resultados obtenidos, podría ser parte de un documento de análisis estadístico (report).

El report comienza aquí.

# generamos valores aleatorios de una distribución Normal
set.seed(123)
x = rnorm(5)
x
## [1] -0.56048 -0.23018  1.55871  0.07051  0.12929
mean(x)
## [1] 0.1936

Podemos también crear gráficos e incluirlos en el report.

hist(x)
plot of chunk test-b1

Podemos ver otro gráfico básico:

par(mar = c(4, 4, .1, .1)); 
plot(x)
plot of chunk test-b

Este report se ha escrito con la ayuda de knitr y los caracteres de inclusión de código R (chunks), los cuales pueden contener distintas opciones que los modifican:

var(x)
## [1] 0.6578
quantile(x)
##       0%      25%      50%      75%     100% 
## -0.56048 -0.23018  0.07051  0.12929  1.55871

Y se pueden escribir dos chunks sucesivamente, como se ve en el siguiente ejemplo:

sum(x^2) # chi-square distribution with df 5
## [1] 2.818

sum((x - mean(x))^2) # df is 4 now
## [1] 2.631

Hecho.

Algunas cosas más

Código dentro del texto

Inline R code is also supported, e.g. the value of x is -0.5605, -0.2302, 1.5587, 0.0705, 0.1293, and 2 × π = 6.2832.

Matemáticas

Escribimos expresiones matemáticas con ayuda de código LaTeX: \(f(\alpha, \beta) \propto x^{\alpha-1}(1-x)^{\beta-1}\).

Se ha obtenido escribiendo el siguiente código:

$f(\alpha, \beta) \propto x^{\alpha-1}(1-x)^{\beta-1}$

Miscelánea

You can indent code chunks so they can nest within other environments such as lists.

  1. the area of a circle with radius x

    pi * x^2
    
    ## [1] 0.98688 0.16645 7.63272 0.01562 0.05251
    

  2. OK, that is great

Para compilar este documento hemos tenido que ejecutar algo así:

library(knitr)
library(knitrBootstrap)
setwd("~/Documents")
knit_bootstrap_Rmd(input='tc_introduccionaR.Rmd', code_style="Brown Paper", 
                  chooser=c("boot", "code"), 
                  show_code=TRUE,
                  show_output=TRUE,
                  show_figure=TRUE,
                   thumbsize=6)
browseURL("tc_introduccionaR.html")

Instalación de R y RStudio

Cuestiones básicas en R

Buscar ayuda sobre R

Localmente:

?function_name
??function_name
RSiteSearch("function_name")

Online:

Es bueno especificar en que condiciones estaba el sistema utilizado:

print(sessionInfo(), locale = FALSE)
## R version 3.0.1 (2013-05-16)
## Platform: x86_64-apple-darwin10.8.0 (64-bit)
## 
## attached base packages:
## [1] stats     graphics  grDevices utils     datasets  methods   base     
## 
## other attached packages:
## [1] knitrBootstrap_0.8.0 markdown_0.6.3       knitr_1.4.1         
## 
## loaded via a namespace (and not attached):
## [1] digest_0.6.3   evaluate_0.4.7 formatR_0.9    slidify_0.3.52
## [5] stringr_0.6.2  tools_3.0.1    whisker_0.3-2  yaml_2.1.8

Definir objetos en R

# asignar valores a variables
n = 5      # es posible pero
n <- 5     # es preferible, o ...
45 -> n
rm(n)

# Los objetos R pueden ser de varios tipos, pero probablemente los más comunes son 'numeric' y 'character'
( num <- 3.14 )  # observa que colocar una instrucción entre paréntesis también imprime en la consola
## [1] 3.14
( char <- 'cualquier cadena de texto' )
## [1] "cualquier cadena de texto"

Tipos de datos en R

# Vector: (una sola dimensión, todos los valores del mismo tipo)
vec1 <- 1:10
class(vec1)
## [1] "integer"
## [1] "integer"
vec2 <- letters[1:10]
class(vec2)
## [1] "character"
## [1] "character"
# data.frame: cada columna es un vector de la misma longitud, 
#             pero vectores adyacentes pueden contener diferentes cosas
# matrix: como un data.frame excepto todos los valores son numéricos
# list: (cualquier dimensión, distintos tipos y distintas longitudes)
l1 <- list(A = data.frame(x = 1:10, y = rnorm(10)),B = 1, C = letters[1:3])
str(l1)
## List of 3
##  $ A:'data.frame':   10 obs. of  2 variables:
##   ..$ x: int [1:10] 1 2 3 4 5 6 7 8 9 10
##   ..$ y: num [1:10] 1.715 0.461 -1.265 -0.687 -0.446 ...
##  $ B: num 1
##  $ C: chr [1:3] "a" "b" "c"

Tipo de datos: vectores.

# crear un VECTOR (array) usando la función concadenar 'c()' 
( vec <- c(2,5,8,3,7) )
## [1] 2 5 8 3 7
# un vector serie
( vec <- 10:20 )
##  [1] 10 11 12 13 14 15 16 17 18 19 20
# para acceder a las componentes de los vectores en R se usan corchetes [ ]  de varias formas
vec[3]
## [1] 12
vec[3:6]
## [1] 12 13 14 15
vec[ c(1,3,8) ]
## [1] 10 12 17
vec[vec > 15]
## [1] 16 17 18 19 20
vec>15
##  [1] FALSE FALSE FALSE FALSE FALSE FALSE  TRUE  TRUE  TRUE  TRUE  TRUE

# chequear si un vector contiene un valor
5 %in% vec
## [1] FALSE
12 %in% vec
## [1] TRUE

# encontrar el primer índice de una búsqueda 
( x = c('one', 'five', 'two', 3, 'two') )
## [1] "one"  "five" "two"  "3"    "two"
match('two', x)
## [1] 3
match(c('two','five'), x)
## [1] 3 2

También:

rep(1,5)
## [1] 1 1 1 1 1
rep(c(2,3),4)
## [1] 2 3 2 3 2 3 2 3

Tipo de datos: matrices y arrays.

# una MATRIZ (MATRIX) es un vector 2D (esencialmente es un vector de vectores) de un mismo tipo de datos
( matrx = matrix(1:15, 3, 5,byrow=TRUE) )
##      [,1] [,2] [,3] [,4] [,5]
## [1,]    1    2    3    4    5
## [2,]    6    7    8    9   10
## [3,]   11   12   13   14   15
( matrx <- 1:12 )      # vector a una matriz
##  [1]  1  2  3  4  5  6  7  8  9 10 11 12
dim(matrx) <- c(3,4)
print(matrx)
##      [,1] [,2] [,3] [,4]
## [1,]    1    4    7   10
## [2,]    2    5    8   11
## [3,]    3    6    9   12
t(matrx) # la traspuesta de una matriz se obtiene fácilmente
##      [,1] [,2] [,3]
## [1,]    1    2    3
## [2,]    4    5    6
## [3,]    7    8    9
## [4,]   10   11   12

# un ARRAY es un vector genérico pero con más flexibilidad. Un array 1D es lo mismo que un vector,
# y un array 2D es como una matriz. Pero los arrays pueden almacenar datos con 'n' dimensiones:
( arry <- array(1:24, dim=c(4,3,2)) )
## , , 1
## 
##      [,1] [,2] [,3]
## [1,]    1    5    9
## [2,]    2    6   10
## [3,]    3    7   11
## [4,]    4    8   12
## 
## , , 2
## 
##      [,1] [,2] [,3]
## [1,]   13   17   21
## [2,]   14   18   22
## [3,]   15   19   23
## [4,]   16   20   24
# Usar corchetes sobre arrays
arry[12]        # un único criterio (argumento) selecciona el n-ésimo elemento del array
## [1] 12
arry[3,1,2]     # o usar múltiples argumentos refleja la dimensionalidad del array
## [1] 15
arry[,,2]
##      [,1] [,2] [,3]
## [1,]   13   17   21
## [2,]   14   18   22
## [3,]   15   19   23
## [4,]   16   20   24
arry[,1,]
##      [,1] [,2]
## [1,]    1   13
## [2,]    2   14
## [3,]    3   15
## [4,]    4   16

Tipo de datos: data.frame.

Son los de más interés en aplicaciones estadísticas.

# un DATA.FRAME es como una matriz, pero acomoda variables (columnas) con diferentes tipos de datos
(df <- data.frame(name = c('Matt','Kate','Jacquie','Simon','Nita'), 
                  age = c(35,29,32,35,39)))
##      name age
## 1    Matt  35
## 2    Kate  29
## 3 Jacquie  32
## 4   Simon  35
## 5    Nita  39
# Pueden verse más claramente
View(df)
# examinar su estructura interna
str(df)
## 'data.frame':   5 obs. of  2 variables:
##  $ name: Factor w/ 5 levels "Jacquie","Kate",..: 3 2 1 5 4
##  $ age : num  35 29 32 35 39

# interrogar o consultas a los datos con corchetes
df[1,]
##   name age
## 1 Matt  35
df[2:3,]
##      name age
## 2    Kate  29
## 3 Jacquie  32
df[,1]
## [1] Matt    Kate    Jacquie Simon   Nita   
## Levels: Jacquie Kate Matt Nita Simon
df[2,1]
## [1] Kate
## Levels: Jacquie Kate Matt Nita Simon

# los objetos data.frame y matrix pueden tener nombres de variables (columna) y nombres de registros (row)
dimnames(df)
## [[1]]
## [1] "1" "2" "3" "4" "5"
## 
## [[2]]
## [1] "name" "age"
colnames(df)
## [1] "name" "age"
names(df)     # no válido para objetos matrix
## [1] "name" "age"
row.names(df)
## [1] "1" "2" "3" "4" "5"

# interrogar o consultar data.frames por nombres de variables usando el operador '$'. El resultado es un vector simple
df$name
## [1] Matt    Kate    Jacquie Simon   Nita   
## Levels: Jacquie Kate Matt Nita Simon
df$name[2]
## [1] Kate
## Levels: Jacquie Kate Matt Nita Simon

# los nombres pueden reasignarse
names(df) <- c('person','years')
row.names(df) <- c('R1','R2','R3','R4','R5')
print(df)
##     person years
## R1    Matt    35
## R2    Kate    29
## R3 Jacquie    32
## R4   Simon    35
## R5    Nita    39

# chequear dimensiones de objetos vector/matrix/array/data.frame
length(vec)
## [1] 11
dim(df)
## [1] 5 2
dim(arry)
## [1] 4 3 2
nrow(df)
## [1] 5
ncol(df)
## [1] 2

Lectura y escritura de datos en R

Podemos grabar todos (o solamente los que queramos) los datos activos Environment (entorno o espacio de trabajo) en un momento dado (save) y cargarlo en cualquier momento (load):

save('datos_entorno_f13092013.Rdata')   
load('datos_entorno_f13092013.Rdata')

Para leer datos en R desde ficheros se utilizan las siguientes funciones, las cuales disponen de muchas opciones para determinar las condiciones de lectura o importación de los datos. Desde RStudio podemos usar la utilidad para importar datos Import Dataset en el panel Environment.

read.table(file)    lee datos de un fichero "file" especificando opciones:
                     header=TRUE, sep=" ", as.is=TRUE (previene vectores caracteres -> factores)
read.csv("filename",header=TRUE)   ídem, por defecto lee ficheros separados por comas
read.delim("filename",header=TRUE) ídem, por defecto lee ficheros separados por tabulador
read.fwf(file,widths,header=FALSE,sep="",as.is=FALSE) lee datos en formato fijo, donde
                 se especifica la opción "widths=vecentero", que da las anchuras de los campos

Podemos escribir los datos (data.frame) cargados en memoria que deseemos (o en el entorno o espacio de trabajo de R) con las mismas posibilidades que las que acabamos de ver para leer ficheros (separados por distintos delimitadores, con cabecera o no, etc) con la función:

write.table(x,file="fichero.ext",row.names=TRUE,col.names=TRUE,sep=" ")

Para leer datos copiados de Excel en R (o incluso de otra aplicación) en formato data.frame:

x <- read.delim("clipboard")     los datos copiados (Ctrl+C) se guardan en x (windows)
x = read.table(pipe("pbpaste")) los datos copiados (cmd+C) se guardan en x (mac)

Para leer de otros formatos de ficheros, como por ejemplo SPSS, SAS, etc, usar el paquete de R foreign (debe estar instalado previamente):

require('foreign')
xx = read.spps(fichero)

Cálculos básicos en R

Operadores y operaciones básicas en R

R dispone de los operadores matemáticos habituales:

+, -, *, /, %/% (división entera), %% (resto división entera), ^ (exponenciación)

Operadores lógicos (TRUE o T, y FALSE o F) entre valores numéricos o cadenas:

==      igualdad
!=      distinto
<       menor
<=      menor o igual
>       mayor
>=      mayor o igual
|       o lógico
&       y lógico
all()   todos verdaderos
any()   alguno verdadero

Las funciones matemáticas en R más conocidas serían (si se aplican a vectores, matrices, etc, se efectúan sobre cada elemento)

sqrt,abs,sin,cos,tan,asin,acos,atan,atan2,log,log10,exp
round(x, n), log(x,base)

Funciones útiles en Estadística

max(x)              máximo de los elementos de x
min(x)              mínimos de los elementos de x
which.max(x)        índice (primero) donde se alcanza el máximo
which.min(x)        índice (primero) donde se alcanza el mínimo
which(vlog)         índices donde el valor es TRUE  
range(x)            devuelve c(min(x), max(x))
sum(x)              suma de los elementos de x
diff(x)             diferencias entre elementos consecutivos de x
prod(x)             producto de los elementos de x
mean(x)             media de los elementos de x
median(x)           mediana de los elementos de x
quantile(x,probs=)  cuantiles muestrales correspondientes 
                    a las probabilidades dadas
                    (por defecto 0,.25,.5,.75,1)
weighted.mean(x, w) media de x con pesos o frecuencias w
rank(x)             rangos de los elementos de x
var(x) o cov(x)     varianza de los elementos de x (calculado sobre n-1); 
                    si x es una matriz o data.frame, 
                    se calcula la matriz de varianza-covarianza
sd(x)               desviación típica (estándar) de x
cor(x)              matriz de correlación de x si es matriz o data.frame
var(x, y) o cov(x, y)  covarianza entre x e y, o entre las columnas de x e 
                       y si son matrices o data.frame
cor(x, y)           correlación lineal entre x e y, 
                    o matriz de correlación si son matrices o data.frame

Algunas más:

sort(x)       crea un vector con los elemntos ordenados de x (tiene opciones)
tmp=sort(v,index.return=TRUE)  devuelve elementos ordenados e índices 
                               (s=tmp$x; idx=tmp$ix)
m[order(m[,1], m[,2], m[,3]),]  ordena la matriz m por primera columna, 
                                usa la segunda columna para romper empates, ...

Distrubuciones estadísticas en R

A continuación aparecen las funciones que nos permiten generar números aleatorios de las distintas distribuciones estadísticas, todas ellas llevan una r delante. Si cambiamos esa r por: d, p o q tendríamos la densidad, la función de distribución o la función inversa de la función de distribución o cuantil de las distintas distribuciones (por ejemplo: rnorm, dnorm, pnorm, qnorm) con argumentos casi idénticos.

rnorm(n, mean=0, sd=1) Gaussian (normal)
rexp(n, rate=1) exponential
rgamma(n, shape, scale=1) gamma
rpois(n, lambda) Poisson
rweibull(n, shape, scale=1) Weibull
rcauchy(n, location=0, scale=1) Cauchy
rbeta(n, shape1, shape2) beta
rt(n, df) ‘Student’ (t)
rf(n, df1, df2) Fisher–Snedecor (F) (c2)
rchisq(n, df) Pearson
rbinom(n, size, prob) binomial
rgeom(n, prob) geometric
rhyper(nn, m, n, k) hypergeometric
rlogis(n, location=0, scale=1) logistic
rlnorm(n, meanlog=0, sdlog=1) lognormal
rnbinom(n, size, prob) negative binomial
runif(n, min=0, max=1) uniform

Muy útiles también son:

set.seed(n)               define la semilla del generador aleatorio en n
sample(n)                 obtiene una permutación de los valores del vector 1:n
sample(n,k)               elige k valores del vector 1:n sin reemplazamiento 
sample(v,k,replace=TRUE)  elige k valores del vector v con reemplazamiento   

Operaciones con Matrices

Las operaciones más habituales en R sobre matrices:

t(x)                    transpuesta
diag(x)                 diagonal
*                       multiplicación elemento a elemento en matrices (idem +,-,etc)
%*%                     multiplicación matricial
det(a)                  determinante de una matriz
solve(a,b)              resuelve el sistema lineal  a %*% x = b para  x
solve(a)                calcula la inversa de la matriz a
rowsum(x) y rowSums(x)  suma de filas para una matriz
colsum(x) y colSums(x)  suma de columnas para una matriz
rowMeans(x)             medias para las filas de una matriz
colMeans(x)             medias para las columnas de una matriz
tmp=eigen(A)            autovalores y autovectores de A 
                          (w=tmp$values;V=tmp$vectors)

Existen funciones que nos permiten construir nuevas matrices a partir de otras:

cbind(a,b)    une las matrices a y b por columnas (tienen que tener igual num.filas) 
                las coloca una a la derecha de otra
rbind(a,b)    une las matrices a y b por filas (igual num.columnas)
                las coloca una debajo de otra

Para aplicar determinadas funciones a los distintos elementos de un objeto, en R existen varias funciones que nos facilitan estas operaciones (MUY ÚTILES):

apply(X,INDEX,FUN)    para un vector o array o lista de valores (X) 
                      le aplica una función (FUN) a las marginales 
                      (INDEX, 1=filas, 2=columnas, 3=...) de X
lapply(X,FUN)         aplica FUN a cada elemento de la lista X

Trabajando con cadenas de caracteres en R

Algunas de las funciones de cadenas de caracteres en R más habituales son:

paste(...)            concadena vectores y después convierte a caracteres 
                      (Argumentos: sep,collapse)
substr(x,start,stop)  subcadenas en un vector de caracteres, 
                      puede también asignarse a esta función
strsplit(x,split)     divide x de acuerdo a la subcadena 'split'
tolower(x)            convierte a minúsculas
toupper(x)            convierte a mayúsuculas

Programación en R

R dispone de las herramientas más habituales para crear funciones:

function( arglist ) expr function definition
return(value)
if(cond) expr
if(cond) expr.siverdad else expr.sifalso
for(var in seq) expr
while(cond) expr
repeat expr
break
next
Usar llaves {} para agrupar instrucciones o expresiones
ifelse(test, yes, no) 

Ejemplo sencillo de crear una función:

varianza = function(x) {
 varlocal = sum((x-mean(x))^2)/length(x);
 return(varlocal)
}

Podemos llamarla como:

 varianza(c(3,2,9,1,3,2))
## [1] 6.889

Para devolver más de un argumento en una función se devuelven objetos tipo lista.