resumen de r
TRANSCRIPT
ÍNDICE
1. INTRODUCCIÓN.........................................................................................................................................3
# La ayuda en R..........................................................................................................................................................4
2. VECTORES.................................................................................................................................................4
# Operaciones aritméticas...................................................................................................................4
# Operaciones logarítmicas.................................................................................................................4
# Funciones trigonométricas..............................................................................................................4
# Otras funciones matemáticas........................................................................................................5
# Operaciones de redondeo................................................................................................................5
# Operaciones de extremos.................................................................................................................5
# Operaciones acumulativas...............................................................................................................5
# Infinitos y no números........................................................................................................................5
# Operadores de comparación:.........................................................................................................5
# Operadores lógicos:.............................................................................................................................5
# Operaciones de conjuntos:..............................................................................................................5
# Ordenación de vectores.....................................................................................................................6
# Generación de sucesiones................................................................................................................6
# Generación de secuencias aleatorias........................................................................................6
# Funciones estadísticas.......................................................................................................................6
# Vectores con nombres........................................................................................................................7
# Acceso a los elementos de un vector........................................................................................7
# Modificar los elementos de un vector.......................................................................................7
# Funciones which.....................................................................................................................................7
# Vectores de caracteres......................................................................................................................7
Más en: http://www.endmemo.com/program/R/.......................................................................................................9
3. Factores - DATOS EN CATEGORÍAS..........................................................................................10
# Discretizar datos..................................................................................................................................10
4. SERIES TEMPORALES........................................................................................................................11
5. PAQUETES DE R...................................................................................................................................11
6. LISTAS.......................................................................................................................................................12
7. MATRICES................................................................................................................................................12
# Acceso a los datos de una matriz.............................................................................................13
# Matrices de índices.............................................................................................................................13
# Operaciones aritméticas con matrices...................................................................................13
# Resolución de sistemas de ecuaciones lineales:.............................................................14
# Autovalores y autovectores..........................................................................................................14
# Concatenación de matrices:..........................................................................................................14
# La función apply...................................................................................................................................14
# La función array()................................................................................................................................15
8. MARCOS DE DATOS (DATA FRAMES)......................................................................................15
9. PROGRAMACIÓN EN R Y OPERACIONES DE APLICACIÓN SIMULTÁNEA DE FUNCIONES.........................................................................................................................................................16
# Definición de funciones:..................................................................................................................16
# La familia apply....................................................................................................................................18
10. LECTURA DE MARCOS DE DATOS DESDE FICHEROS................................................18
# Primer formato de fichero (TXT):...............................................................................................18
# Segundo formato de fichero (CSV - versión inglesa):...................................................19
# Segundo formato de fichero (CSV - versión española):...............................................19
# Tercer formato de fichero (XLS).................................................................................................20
11. GUARDAR Y LEER DATOS.........................................................................................................21
12. EXPORTAR DATOS........................................................................................................................21
13. ATRIBUTOS DE OBJETOS...........................................................................................................22
# Atributos intrínsecos: modo y longitud.................................................................................22
# Atributos no intrínsecos de un objeto....................................................................................24
14. MANEJO DE DATOS.......................................................................................................................25
# Manejo de datos: Recodificación de una variable...........................................................25
# Manejo de datos: Cálculo de nuevas variables.................................................................25
# Manejo de datos: Filtrado de datos.........................................................................................26
15. RESÚMENES NUMÉRICOS.........................................................................................................26
# Tablas de frecuencias para variables categóricas..........................................................26
# Medidas de localización, dispersión y forma para vbles cuantitativas cont..26
16. ELEMENTOS GRAFICADORES EN R.....................................................................................28
# Disposición de una gráfica.............................................................................................................29
# Gráficos de alto nivel........................................................................................................................30
# Gráficos de bajo nivel.......................................................................................................................31
1
# Funciones interactivas.....................................................................................................................31
# Algunos Parámetros para Graficar en R................................................................................31
# Conjuntos de datos.............................................................................................................................32
17. GRÁFICOS ESTADÍSTICOS UNIVARIANTES.....................................................................33
# Diagrama de barras...........................................................................................................................33
# Diagrama de puntos..........................................................................................................................34
PALETAS DE COLORES...........................................................................................................................35
# Diagrama de dispersión...................................................................................................................35
# Diagrama de caja y bigote.............................................................................................................35
# Histograma..............................................................................................................................................36
# Gráfico de densidad...........................................................................................................................37
18. GRÁFICOS ESTADÍSTICOS BIVARIANTES.........................................................................38
19. GRÁFICOS TRIDIMENSIONALES............................................................................................38
20. MÚLTIPLE GRÁFICOS POR PÁGINA.....................................................................................38
21. GRÁFICOS DE SERIES TEMPORALES..................................................................................38
22. DISTRIBUCIONES DE PROBABILIDAD................................................................................39
23. MUESTREO ALEATORIO.............................................................................................................39
24. PRUEBAS DE NORMALIDAD....................................................................................................40
# Mediante el cálculo de los estadísticos de simetría (skewness) y de apuntamiento (kurtosis)......................................................................................................................40
# Mediante los gráficos: Histogramas, diagrama de hojas y ramas (stem) o gráfico de normalidad (qqnorm).....................................................................................................40
# Mediante test estadísticos....................................................................................................................41
1. INTRODUCCIÓN
R es un entorno integrado de programas para manipulación de datos, cálculo y gráficos.
R es un lenguaje de expresiones con una sintaxis muy simple.
Distingue entre mayúsculas y minúsculas.
Las órdenes elementales consisten en: Expresiones (se evalúa, se imprime y su valor se pierde) Asignación (evalúa una expresión, no la imprime y guarda
su valor en una vble.) (Operador asignación ‘ <-‘)Si al terminar una línea la orden no está sintácticamente completa, R mostrará un signo de continuación el la siguiente línea ‘ + ‘.
Las órdenes se separan mediante ‘ ; ’ o un cambio de línea. Y se pueden agrupar mediante llaves ‘ { ‘ y ‘ } ‘.# -> indica un comentario hasta el final de la línea
Las entidades que R crea y manipula se denominan objetos. Éstos pueden ser vbles, vbles indexadas, cadenas, funciones u otras estructuras más complejas. Las clases de objetos más comunes son:
vector el tipo básico array generalización multidimensional de vector factor representan datos categóricos lista vectores de elementos no homogéneos hoja de datos (data frame) estructuras matriciales. Cada
columna puede ser de un tipo diferente función ya sea de R, de un paquete o definida por el
usuario
Listado de objetos ls(),objects()Borrado de objetosrm(obj1 [, obj2, ... , objn])
rm(list = ls()) # borrar todo del workspace
2
La función setwd() permite cambiar el directorio donde estamos trabajando (working directory). Hay que tener en cuenta que los datos se guardarán en ese directorio. Y getwd() indica cuál es el actual directorio de trabajo.
La función save() nos permite almacenar varios objetos, por ejemplo, una o varias hojas de datos, en archivos para poder utilizarlos con posterioridad.save(Datos.Pruebas,file="Pruebas.RData")
Podemos indicar el fichero a cargar mediante la ventana "Seleccionar archivo"ruta <- file.choose()
Mediante la función load(), recuperamos la hoja de datos:load("Pruebas.RData") ó load(ruta)
Supongamos que estamos dentro del directorio de trabajo correcto (o eso pensamos) y queremos ver el nombre de los archivos de ese directorio. Tan sólo tenemos que ejecutar dir() y nos saldrán todos los archivos del directorio.Sin embargo, si sólo queremos saber el nombre de los archivos del directrorio que son archivos de datos de R, escribiremos dir(pattern=".RData") o dir(pattern=".rda"). Con la opción pattern le estamos pidiendo sólo los archivos que incluyan en su nombre la expresión que corresponde con las extensiones de los archivos de datos de R, .RData y .rda.
# Nombres para los objetos Los nombres válidos para un objeto son combinaciones de
letras, números y el punto (“.”). Los nombres no pueden empezar con un número.
R es “case-sensitive”: x != X. Hay nombres reservados (“function”, “if”, etc.). Otras consideraciones:
o El uso del “.” es distinto del de C++.o Mejor evitar nombres que R usa (ej., “c”) (se puede
arreglar).> c <- 4; x <- c(3, 8); c
> rm(c); co 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
# La ayuda en R help(“<función>”) help.start() -> Muestra 1 pág d ayuda en 1 navegador de
Internet Con help.start(browser = “explorer”) especifica el
navegador a usar. apropos (“<función>”) -> Permite buscar por nombre help.search(“<función>”) -> Busca por nombre y
descripciónsearch()
Salir de R -> función q
Más en: http://www.uam.es/personal_pdi/ciencias/joser/paginaR.html
3
VECTORES
# Colección ordenada de elementos del mismo tipo.# c en realidad concatena vectores
a <- c(1,2,3)v4 <- c(a,0,a)v4
# En las operaciones aritméticas con vectores el vector más corto se recicla
# Operaciones aritméticashelp("+")# Funciones: + (suma), - (resta), * (multiplicación), / (división),# ^ (exponenciación), %% (resto división entera),# %/% (cociente división entera).
# Operaciones logarítmicashelp("log")# Funciones: log (logaritmo natural), log10 (logaritmo en base 10),# log2 (logaritmo en base 2), logb (logaritmo en cualquier# base), log1p (calcula log(1+x) con precisión para# |x| << 1), exp (función exponencial), expm1 (calcula# exp(x)-1 con precisión para |x| << 1).exp(0.000001)-1expm1(0.000001)
# Funciones trigonométricashelp("Trig")# Funciones: cos (coseno), sin (seno), tan (tangente),# acos (arcocoseno), asin (arcoseno), atan (arcotangente),# atan2 (atan2(y,x) es el ángulo entre el eje x y el vector# del origen al punto (x,y)).# Nota: los ángulos son en radianes.
# Otras funciones matemáticashelp("abs")# Funciones: abs (valor absoluto), sqrt (raíz cuadrada).
# Operaciones de redondeohelp("round")# Funciones: ceiling (redondeo hacia arriba), floor (redondeo hacia# abajo), round (redondeo al más cercano), signif (redondeo# al número de dígitos significativos especificado), trunc# (eliminar decimales).
# Operaciones de extremoshelp("max")# Funciones: max (máximo), min (mínimo), pmax (máximo paralelo),# pmin (mínimo paralelo).max(y,z)pmax(y,z)
# Operaciones acumulativashelp("sum")help("prod")help("cumsum")# Funciones: cumsum, cumprod, cummax, cummin (suma, producto, máximo y mínimo acumulativos)sum(z)prod(z)cumsum(z)cumprod(z)cummin(c(y,z))cummax(c(y,z))
# Infinitos y no númerospipi / 0 # Infinito positivo-pi / 0 # Infinito negativo
4
0 / 0 # No es un número1/0 + 1/0 # Infinito1/0 - 1/0 # No es un número
# Operadores de comparación:# Valores lógicos: TRUE o T, FALSE o Fhelp("<")# Funciones: <, >, <=, >=, ==, !=w <- c(2, z, 4)w == y
# Operadores lógicos:help("!")# Funciones: ! (negación), & (conjunción), | (disyunción),# xor (disyunción exclusiva).
Las formas &&, || se evalúan de izquierda a derecha, examinando sólo el primer elemento de cada vector (si decide). Se suelen usar dentro de instrucciones “if”.
w != y!(w == y)
# Operaciones de conjuntos:help("union")help("%in%")# Funciones: union (unión), intersect (intersección),# setdiff (diferencia de conjuntos), setequal (igualdad de# conjuntos), is.element (pertenencia, idéntico a %in%),# match (posiciones en un vector).
conj1 <- c(1,2,3,4)conj2 <- c(3,4,5)conj3 <- c(2,4,3,1)union(conj1,conj2)intersect(conj1,conj2)setdiff(conj1,conj2)setequal(conj1,conj2)setequal(conj1,conj3)
is.element(2,conj1)is.element(c(2,6,4,8),conj1)match(c(2,1),conj3)
# Ordenación de vectoreshelp("rank") Devuelve un vector con las posiciones que ocuparía cada elemento del vector si estuviera ordenadorank(c(2,-2,0)) -> [1] 3 1 2rank(c(2,-2,0,2)) -> [1] 3.5 1.0 2.0 3.5rank(c(2,-2,0,2,2)) -> [1] 4 1 2 4 4
help("order") Devuelve un vector con las posiciones que ocuparía cada elemento del vector si estuviera ordenado (sus valores absolutos, sin signo)order(c(2,-2,0)) -> [1] 2 3 1order(c(2,-2,0,2)) -> [1] 2 3 1 4order(c(2,-2,0,2,2)) -> [1] 2 3 1 4 5
help("sort") Devuelve un vector ordenado, por defecto crecientemente.# Funciones: sort (ordenar), is.unsorted (predicado de no ordenado)is.unsorted(w)sort(w) # order y sort admiten decreasing = TRUE.sort(w,decreasing=T)
help("rev") Devuelve un vector con los mismos elementos en posiciones invertidas> rev(c(5, 1, 8, 3)) -> [1] 3 8 1 5
# Generación de sucesiones
# El operador :1:10 -> [1] 1 2 3 4 5 6 7 8 9 1015:11 -> [1] 15 14 13 12 111:10-1 -> [1] 0 1 2 3 4 5 6 7 8 91:(10-1) -> [1] 1 2 3 4 5 6 7 8 9
5
# La función seqhelp("seq")seq(10) -> [1] 1 2 3 4 5 6 7 8 9 10seq(3,10) -> [1] 3 4 5 6 7 8 9 10seq(1,10,by=3) -> [1] 1 4 7 10seq(1,10,by=4) -> [1] 1 5 9seq(1,10,length=3)-> [1] 1.0 5.5 10.0seq(w) # Sucesión de 1 hasta la longitud de w# La función rep replica los elementos de un vectorhelp("rep")rep(1:4, 2) -> [1] 1 2 3 4 1 2 3 4rep(1:4, each = 2) -> [1] 1 1 2 2 3 3 4 4rep(1:4, c(2,2,2,2)) -> [1] 1 1 2 2 3 3 4 4rep(1:4, c(2,1,2,1)) -> [1] 1 1 2 3 3 4rep(1:4, length.out = 6)-> [1] 1 2 3 4 1 2rep(1:4, each = 2, len = 4) # Los nombres de las opciones
se pueden abreviarrep(1:4, each = 2, len = 10)
# Generación de secuencias aleatorias
> sample(5) # Permutaciones aleatorias [1] 3 5 2 4 1> sample(5, 3) # Variaciones aleatorias -> [1] 2 4 3> x <- 1:10> sample(x) -> [1] 5 3 8 9 10 7 2 6 1 4> sample(x, replace = TRUE)> sample(x, length = 2* length(x), replace = TRUE)> probs <- x/sum(x)> sample(x, prob = probs)
# Simulación de tiradas de un dadosample(1:6, 10, replace = T) # Con reemplazamientosample(1:6, 10, replace = T, prob = c(rep(1/11, 5), 6/11)) # Dado cargado
Números aleatorios: rDistribución(n,parámetros)
> rnorm(10) # rnorm(10, mean = 0,sd = 1)> runif(8,min=2,max=10)
# Funciones estadísticassummary(w)
help("mean")mean(w) # Mediamean(w,trim=0.2) # Media recortada
help("median")median(w) # Mediana
help("quantile")quantile(w) # Cuantiles (o percentiles)quantile(w,seq(0,100,by=10)/100)
help("sd")help("var")sd(w) # Desviación típicavar(w) # Varianzasd(w)^2sd(w)^2 == var(w)all.equal(sd(w)^2,var(w)) # Comparador con una ligera
toleranciaall.equal(sd(w),var(w))
help("IQR")IQR(w) # Rango intercuartílico
help("range")range(w) # Rango (mánimo y míximo)range(x,y,z,w)
# Vectores con nombresventas <- c(45,43,46,48,51)names(ventas) -> [1] NULLnames(ventas) <- c("Lun","Mar","Mie","Jue","Vie")ventas -> [1] Lun Mar Mie Jue Vie
45 43 46 48 51
# Acceso a los elementos de un vector
# Mediante un vector lógicoventas > 45 -> [1] Lun Mar Mie Jue Vie
FALSE FALSE TRUE TRUE TRUEventas[ventas > 45] -> [1] Mie Jue Vie
6
46 48 51# Mediante un vector de enteros positivosventas[c(3,4,5)] -> [1] Mie Jue Vie
46 48 51# Mediante un vector de enteros negativosventas[-c(1,2)] -> [1] Mie Jue Vie
46 48 51# Mediante un vector de cadenas de caracteresventas[c("Mie","Jue","Vie")] -> [1] Mie Jue Vie
46 48 51
# Modificar los elementos de un vectorlength(ventas) # Longitud del vectorventas[5] <- 50ventas[-c(1,2)] # Quita las posiciones 1 y 2ventas[-c(1,2)] <- c(45,47,49)ventasventas[-1] <- c(45,46)ventasventas[ventas > 45] <- ventas[ventas > 45]-1ventasventas[c("Lun","Mie","Vie")] <- 50ventas
ventas[6] <- 50ventasnames(ventas)[6] <- "Sab"ventasventas[8] <- 40ventas # NA es el objeto No Disponible (Not Available)
# Funciones whichventas > 45which(ventas > 45)# Devuelve las posiciones de los
elementos TRUE de un vector lógicowhich.max(ventas) # Posición del primer máximowhich.min(ventas) # Posición del primer mínimo
# Vectores de caracteres
# La función paste concatena cadenas:
> paste(c("a", "b"), c("c", "d")) -> [1] "a c" "b d"> paste(c("a", "b", "c", "d"), c("e", "f"), "g") ->[1] "a e g" "b f g" "c e g" "d f g"> paste(c("a", "b", "c", "d"), 1:4, sep = "-") ->[1] "a-1" "b-2" "c-3" "d-4"> paste(c("a", "b", "c", "d"), 1:4, sep = "-", collapse = " ") -> [1] "a-1 b-2 c-3 d-4"
# La función outer aplica una misma función a pares de elementos:> outer(c(1, 2), 1:4) # Por defecto multiplica. [,1] [,2] [,3] [,4][1,] 1 2 3 4[2,] 2 4 6 8> outer(c(1, 2), 1:4, FUN = "+") [,1] [,2] [,3] [,4][1,] 2 3 4 5[2,] 3 4 5 6> outer(c("a", "b", "c", "d"), 1:3, FUN = "paste") [,1] [,2] [,3] [1,] "a 1" "a 2" "a 3"[2,] "b 1" "b 2" "b 3"[3,] "c 1" "c 2" "c 3"[4,] "d 1" "d 2" "d 3"
# Ejemplo de simulación sobre una baraja española> baraja <- outer(c("A", 2:10, "S", "C", "R"), c("O", "C", "E", "B"), FUN = "paste")> baraja [,1] [,2] [,3] [,4] [1,] "A O" "A C" "A E" "A B" [2,] "2 O" "2 C" "2 E" "2 B" [3,] "3 O" "3 C" "3 E" "3 B" [4,] "4 O" "4 C" "4 E" "4 B" [5,] "5 O" "5 C" "5 E" "5 B" [6,] "6 O" "6 C" "6 E" "6 B" [7,] "7 O" "7 C" "7 E" "7 B" [8,] "8 O" "8 C" "8 E" "8 B" [9,] "9 O" "9 C" "9 E" "9 B" [10,] "10 O" "10 C" "10 E" "10 B"[11,] "S O" "S C" "S E" "S B" [12,] "C O" "C C" "C E" "C B"
7
[13,] "R O" "R C" "R E" "R B"
> sample(baraja, 5) # Elegir 5 cartas[1] "C E" "A B" "8 C" "S C" "5 B"
# Ejemplo de simulación de tiradas de dos dados> dados <- outer(1:6, 1:6, FUN = "paste")> dados [,1] [,2] [,3] [,4] [,5] [,6] [1,] "1 1" "1 2" "1 3" "1 4" "1 5" "1 6"[2,] "2 1" "2 2" "2 3" "2 4" "2 5" "2 6"[3,] "3 1" "3 2" "3 3" "3 4" "3 5" "3 6"[4,] "4 1" "4 2" "4 3" "4 4" "4 5" "4 6"[5,] "5 1" "5 2" "5 3" "5 4" "5 5" "5 6"[6,] "6 1" "6 2" "6 3" "6 4" "6 5" "6 6"
> sample(dados, 10, replace = T) # Realizar 10 tiradas [1] "2 6" "1 2" "6 3" "2 3" "1 2" "1 4" "1 4" "6 1" "1 5" "2 1"Otro ejemplo
> columna.a <- LETTERS[1:5]; columna.b <- 10:15> columna.a; columna.b
[1] "A" "B" "C" "D" "E"[1] 10 11 12 13 14 15
> juntar <- paste(columna.a, columna.b, sep ="")> juntar
[1] "A10" "B11" "C12" "D13" "E14" "A15"
> x <- paste(LETTERS[1:5], collapse="")> x
[1] "ABCDE"
Extraer una subcadena
> substr("abcdef",2,4) -> [1] "bcd"
> x<-"abcdef"> substr(x, 3, 5) <- c("uv")> x -> [1] "abuvef"
Otras funciones de manipulación de caracteres: nchar, grep, match, pmatch, tolower, toupper, sub, gsub, regexpr.
s <- "EndMemo.com R Language Tutorial"substr(s,0,7) # Devuelve [1] "EndMemo"
Obtener la longitud de una cadena:nchar(s) # Devuelve [1] 31
Convertir a mayúsculas:x <- toupper(s)x # Devuelve [1] "ENDMEMO.COM R LANGUAGE TUTORIAL"
Convertir a minúsculas:x <- tolower(s)x # Devuelve [1] "endmemo.com r language tutorial"Dividir la cadena en la letra "o":x <- strsplit(s,"o")x # Devuelve [[1]][1] "EndMem" ".c" "m R Language Tut" "rial"
Concatena dos cadenas:x <- paste(x," -- String Functions",sep="")x # Devuelve [1] "endmemo.com r language tutorial -- String Functions"
Reemplaza subcadenas:x <- sub("Tutorial","Examples",s)x # Devuelve [1] "EndMemo.com R Language Examples"
Más en: http://www.endmemo.com/program/R/
grep(value = FALSE) devuelve un vector de posiciones de las cadenas de x que contienen la subcadena indicadastr <- c("Regular", "expression", "examples of R language")x <- grep("ex",str,value=F)x # Devuelve [1] 2 3
grep(value = TRUE) devuelve un vector de las cadenas de x que contienen la subcadena indicada.
8
x <- grep("ex",str,value=T)x # Devuelve [1] "expression" "examples of R language"
grepl devuelve un vector lógico (indicando los elementos que contienen o no la subcadena).x <- grepl("ex",str)x # Devuelve [1] FALSE TRUE TRUE
9
2. Factores - DATOS EN CATEGORÍAS
Un factor es un vector utilizado para especificar una clasificación discreta de los elementos de otro vector de igual longitud (tipo de vector para datos cualitativos). En R existen factores nominales (función factor) y factores ordinales (función ordered).
Antes de utilizar un vector con caracteres (vble. cualitativa) dentro de un análisis, 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
Funciones: factor codifica un vector como un factor; es decir, clasifica
sus elementos en distintas categorías. levels permite manejar (incluso renombrar) los nombres
de las distintas categorías de un factor. nlevels podemos saber cuántas categorías contiene un
factor. Si se puede considerar un orden entre las categorías de un
factor, entonces hay que usar la función ordered para crearlo. En este caso, con el argumento levels podemos establecer el orden inicial entre las categorías.Ej.: factor.cigarrillos <-
ordered(vect.cigarrillos, levels = c("Pocos", "Bastantes", "Muchos")) cut, divide el rango de una vble cuantitativa en intervalos
y clasifica sus elementos dependiendo de a qué intervalo pertenecen. Mediante el argumento breaks proporcionamos los extremos de los intervalos. Y mediante el argumento include.lowest indicamos si un elemento igual al extremo izquierdo del primer intervalo debe o no incluirse.Ej.:
gl permite crear factores que siguen un patrón repetitivo. Sintaxis:
gl(número de grupos, veces que se repiten, longitud del resultado)gl(3, 2) -> [1] 1 1 2 2 3 3
Levels: 1 2 3gl(3, 2, 12) -> [1] 1 1 2 2 3 3 1 1 2 2 3 3
Levels: 1 2 3 table crea tablas de contingencia
La tabulación cruzada de dos variables cualitativas se consigue con la función table.> table(sexo,nivel)
Pero para introducir una tabla de contingencia también se utiliza la instrucción table. Las variables se definen con sus modalidades con la instrucción expand.grid(var1,var2).
> resultado <- cbind(expand.grid(calif=c("mejor","peor","igual"), + tratam=c("A","B")))> frec <- c(21,34,5,7,12,14)> tabla <- table(calif,tratam)*frec> tabla
tapply permite aplicar de forma simultánea una misma operación a distintos grupos de elementos de un vector clasificados en función de las categorías establecidas por un factor.
# Discretizar datos
La función split(x,f)> split(peso,trat)> split(peso,trat)$A
La función cut> vv <- rnorm(100)> cut1 <- cut(vv, 5)> table(cut1)>
10
> cut2 <- cut(vv, quantile(vv, c(0, 1/4, 1/2, 3/4, 1)))> summary(cut2)> class(cut2)
3. SERIES TEMPORALES
Una serie temporal es una sucesión de observaciones que se encuentran ordenadas en el tiempo.
Funciones: ts permite crear un objeto serie-temporal que guarda los
conjuntos de observaciones realizadas en cada unidad de tiempo. A través de los parámetros start y end podemos especificar en qué unidad de tiempo empieza y/o termina la sucesión de observaciones.
4. PAQUETES DE R
Es posible extender R a través de paquetes.
R consta de un sistema base pero la mayoría de las funciones estadísticas vienen agrupadas en paquetes. Estos se clasifican en tres grupos:
Los que forman parte del sistema base y estarán en cualquier instalación
Paquetes recomendados: aunque no forman parte del sistema base se aconseja su instalación
Otros paquetes desarrollados por investigadores de todo el mundo para tareas o métodos de lo más diverso. Destacan algunos de áreas nuevas como bioinformática, geoestadística, métodos gráficos, etc
Funciones: La función library muestra los paquetes disponibles y
carga los paquetes especificados.
Ej: library("boot") # Cargamos el paquete boot
La función search muestra los paquetes cargados. Al iniciar R se cargan una serie de paquetes por defecto.
Para descargar un paquete basta usar la función detach.
Ej.: detach("package:boot")
11
5. LISTAS
Una lista es una colección de objetos que pueden ser de distintos tipos y que generalmente están identificados por un nombre.
Cada componente puede ser de distinto tipo. Son contenedores generales de datos. Muy flexibles, pero sin estructura. Muchas funciones devuelven una lista o conjunto de resultados de distinta longitud y distinto tipo.
Para crear una lista se utiliza la función list:
Lst <- list(hombre = "Pedro", mujer = "María", casados = TRUE, número.hijos = 3, edad.hijos = c(4, 7, 9))
Para obtener los elementos de una lista se utiliza el operador $.
Para obtener una sublista se utiliza el operador [, pudiendo utilizarse para seleccionar los elementos los mismos cuatro tipos de vectores que se pueden utilizar para seleccionar elementos de un vector.
Lst[c("hombre", "número.hijos")]Lst[c(TRUE, FALSE, FALSE, TRUE, FALSE)]Lst[c(1, 4)]Lst[c(-2, -3, -5)]
Ejemplo que muestra la diferencia de funcionamiento.
Lst$edad.hijos -> [1] 4 7 9Lst["edad.hijos"] -> $edad.hijos
[1] 4 7 9
6. MATRICES
Una matriz es una colección de datos DEL MISMO TIPO que tiene dos dimensiones.
Funciones: La función matrix crea una matriz. Los elementos de la
matriz se proporcionan mediante un vector y se colocan por columnas.Ej matrix(1:10, nrow = 2, ncol = 5)matrix(1:10, nrow = 2)matrix(1:10, ncol = 5)matrix(1:10) # da una matriz de 1 columnamatrix(1:3, nrow = 2, ncol = 3) # Los datos proporcionados de reciclan hasta completar la matrizmatrix(1:12, 4,3) # da una matriz de 4 filas y 3 columnas colocando los elementos por columnas
Mediante el argumento byrow podemos hacer que los elementos se coloquen por filas (Por defecto, byrow=F, e.d. se colocan por columnas)
matrix(1:10, nrow = 2, ncol = 5, byrow = TRUE) dim(M) da acceso a las dimensiones de la matriz
> a <- 1:12> dim(a) <- c(4,3) # Convierte el vector a en una matriz de 4 filas y 3 col.
nrow(M) # número de filas ncol(M) # número de columnas array(vector de datos,vector de dimensiones) Otra forma de crear una matriz
ma <- matrix(scan(), 4, 3, byrow=T) <Enter>1: 1 5 9 <Enter>4: 2 6 10 <Enter>7: 3 7 11 <Enter>10: 4 8 12 <Enter>13: <Enter>Read 12 items
Da como resultado
> ma [,1] [,2] [,3][1,] 1 5 9[2,] 2 6 10[3,] 3 7 11[4,] 4 8 12
12
# Acceso a los datos de una matriz. El operador `[', al igual que con los vectores, permite acceder a los elementos de una matriz. La diferencia es que ahora tenemos que proporcionar dos subíndices.
M <- matrix(1:15, nrow = 3, ncol = 5)M[2, 5]M[5, 3] # índice fuera de rango
Las filas y columnas de las matrices pueden tener nombres, lo que permite seleccionar los elementos por el nombre de la fila y columna en que se encuentre.
rownames(M)rownames(M) <- c("uno", "dos", "tres")> a <- 1:100> ma <- matrix(a, 20)> rownames(ma) <- rownames(ma, do.NULL=F, prefix= "Fila.") Crea un nombre a todas las filas con el prefijo "Fila."
colnames(M)colnames(M) <- c("uno", "dos", "tres", "cuatro", "cinco")> colnames(ma) <- paste("mes", seq(1, dim(ma)[2]), sep="") Crea un nombre a todas las columnas a través de la instrucción paste, donde
seq(1, dim(ma)[2]) devuelve : [1] 1 2 3 4 5
dimnames(ma)<- list(NULL, c(“enero”, “febrero”, “marzo”)) Con esta instrucción no se le da ningún nombre a las filas y se etiquetan las columnas.
Con el operador `[' también es posible seleccionar submatrices de una matriz.
M[1,] # La primera fila de MM[,3] # La tercera columna de MM[c(1, 2), c(1, 3, 4)] # La submatriz de M formada por las
# filas 1 y 2 y las columnas 1, 3 y # 4
# Matrices de índices
IJ1 <- matrix(c(1, 1, 1, 4, 2, 3), ncol = 2, byrow = T)IJ1M[IJ1] # Los elementos (1,1)-ésimo, (1,4)-ésimo y
#(2,3)-ésimo de M
# Operaciones aritméticas con matrices
1.- La expresión se lee de izquierda a derecha.2.- Cualquier vector se recicla repitiendo sus elementos hasta que su tamaño coincida con el del resto de operandos. Si el vector es de principio mayor que una matriz, se produce un error.3.- Las matrices deben tener todas las mismas dimensiones.
v1 <- seq(1, 11, by = 2); M1 <- matrix(v1, nrow = 2)v2 <- seq(0, 10, by = 2); M2 <- matrix(v2, nrow = 2)M3 <- matrix(v1, nrow = 3)
M1 + M2 # Suma elemento a elemento. Las dimensiones deben coincidirM1 + -1:-3 # El vector se reciclaM1 + -1:-7 # El vector es demasiado grandeM1 * M2 # Multiplicación elemento a elementoM1 %*% M3 # Multiplicación usual de matrices. Las dimensiones deben ser adecuadas
Más funciones: t(M1) # La función t proporciona la matriz traspuesta. La
matriz original (M1 ) no se modifica. diag(M1) # Aplicada a una matriz: vector con los
elementos de la diagonal diag(1:3) # Aplicada a un vector: matriz diagonal diag(3) # Aplicada a un número: matriz identidad de
dim 3 det(M1) # Determinante de una matriz. La matriz ha de ser
cuadrada
13
# Resolución de sistemas de ecuaciones lineales:
Coef <- matrix(1:4, nrow = 2, ncol = 2)CoefInd1 <- c(3, 5)Ind2 <- matrix(c(3, 5, 1, 1), nrow = 2, ncol = 2)solve(Coef, Ind1) # Resuelve el sistema Coef %*% x = Ind
#(Ax=b)solve(Coef, Ind2)
solve(Coef) # Devuelve la inversa de la matrizsolve(Coef) %*% CoefCoef %*% solve(Coef)
svd(A) # Descomposición en valores singularesqr(A) # Descomposición QR
# Autovalores y autovectores
eigen(Coef)eigen(Coef, only.values = TRUE) # Si solo queremos calcular los autovalores. Calcular los autovectores es lo más costoso, computacionalmente hablando.
# Concatenación de matrices:M1M2dim(M3) <- c(3, 2)M3
Funciones “bind” (unir)cbind(M1, M2) # Concatena las matrices por columnas. Las matrices deben tener el mismo número de filas. Si concatena vectores => cada vector pasa a ser una COLUMNA de la matriz resultante.rbind(M1, M2) # Concatena las matrices por filas. Las matrices deben tener el mismo número de columnas. Si concatena
vectores => cada vector pasa a ser una FILA de la matriz resultante.
# La función apply La función apply permite aplicar de forma simultánea una misma operación a todas las filas, columnas o elementos de una matriz.
apply(x, Margen, Función, ARGs), donde x es la matriz, MARGEN representa las filas si es =1, las columnas si es =2 ó las filas y las columnas si es c(1,2). FUNCIÓN representa la función a aplicar, y ARGs son argumentos de la misma función.
apply(M1, 1, mean) # Calcula la media de cada filaapply(M1, 2, mean) # Calcula la media de cada columna
Cuando lo que se quiere es sumar o calcular la media de los elementos de las filas o columnas las siguientes funciones son más sencillas y eficientes.
> M1 [,1] [,2] [,3][1,] 1 5 9[2,] 3 7 11
rowSums(M1) -> [1] 15 21colSums(M1) -> [1] 4 12 20rowMeans(M1)-> [1] 5 7colMeans(M1)-> [1] 2 6 10
Por otra parte, la función rowsum calcula, para cada columna de la matriz, la suma de sus elementos agrupándolos previamente según el factor especificado.
M4 <- matrix(1:100, nrow = 20)M4grupos.filas <- gl(2, 1, 20)grupos.filas
14
levels(grupos.filas) <- c("fila impar", "fila par")grupos.filasrowsum(M4, grupos.filas)
# La función array()
Una variable indexada no sólo puede construirse modificando el atributo dim de un vector, sino también directamente mediante la función array, que tiene la forma
array(data=NA, dim=length(data), dimnames=NULL)donde: data: vector de datos que rellenará el array
dim: número de filas y columnas> Z <- array(vector de datos,vector de dimensiones)Por ejemplo, si el vector h contiene 24 números (o incluso menos), la orden
> Z <- array(h, dim=c(3,4,2))
usa h para almacenar en Z una variable indexada de dimensión 3 x 4 x 2. Si el tamaño de h es exactamente 24, el resultado coincide con el de
> dim(Z) <- c(3,4,2)
Sin embargo, si h es más corto de 24, sus valores se repiten desde el principio tantas veces como sea necesario para obtener 24 elementos. El caso extremo, muy común, corresponde a un vector de longitud 1, como en este ejemplo
> Z <- array(0, c(3,4,2))
en que Z es una variable indexada compuesta enteramente de ceros.
Otra forma de construir un array es:x <- 1:64
dim(x) <- c(2,4,8) # Convierte el vector en array de 3 dimis.array(x) # Devuelve [1] TRUE
15
7. MARCOS DE DATOS (DATA FRAMES)
Un marco de datos es una lista tal que para muchos propósitos puede ser considerada como una matriz cuyas columnas posiblemente son de distinto tipo. De esta forma, la lista que forma el marco de datos debe cumplir las siguientes restricciones:
Los componentes deben ser vectores (numéricos, de cadenas o lógicos), factores, matrices numéricas, listas, u otros marcos de datos.
Las matrices, listas y marcos de datos proporcionan tantas variables al nuevo marco de datos como columnas, elementos o variables tengan, respectivamente.
Los vectores numéricos y lógicos y los factores se incluyen tal cual, y los vectores de cadenas se transforman a factores.
Las estructuras de vectores que aparezcan como variables en el marco de datos deben tener todos la misma longitud, y las estructuras de matrices deben tener todas el mismo número de filas.
Nótese que en los data.frame los “character vectors” deben convertirse en factores.Podemos convertir matrices a data.frame con as.data.frame().
Funciones:
La función data.frame crea un marco de datos. rownames(<data.frame>) permite manejar (incluso
renombrar) los nombres de las distintas filas de un marco de datos.
colnames(<data.frame>) permite manejar (incluso renombrar) los nombres de las distintas columnas de un marco de datos.
Acceso a los elementos como una matriz: Dado el marco de datos: estudio
peso altura sexoMarta 65 150 F
Inés 61 135 FJuan 100 210 MCarmen 65 140 F
estudio["Marta", "peso"] -> El peso de Martaestudio[, "peso"] -> La columna de pesos. Es un vector.estudio["Marta",] -> Los datos de Marta. Es un marco de datos.estudio[1:2, 1:2] -> El peso y la altura de Marta e Inés. Es un marco de datos.
Cada fila de un marco de datos es una lista o un marco de datos con una fila:y <- estudio [2,]is.list(y) -> [1] TRUEis.data.frame(y) -> [1] TRUE
Acceso a los elementos como una lista:estudio$peso -> La columna de pesos. Es un vector.estudio[c("peso", "altura")] -> Las columnas de pesos y alturas. Es un marco de datos.
Acceso a los elementos usando las funciones attach y detach:attach(estudio) -> Crea vectores (peso, altura y sexo) que permiten acceder directamente a los datos contenidos en las columnas del marco de datos.detach(estudio) -> Elimina los vectores creados con la función attach
Para que la función attach opere correctamente es necesario no haber definido ningún vector con el mismo nombre que alguna de las columnas del marco de datos. Además, hay que tener en cuenta que las modificaciones realizadas a los vectores creados con la función attach no afectan al marco de datos original.
Si desea seleccionar un subconjunto de una hoja de datos, puede hacerlo con la función subset. Función que puede utilizar también en vectores.
16
8. PROGRAMACIÓN EN R Y OPERACIONES DE APLICACIÓN SIMULTÁNEA DE FUNCIONES
# Definición de funciones:
media.desv <- function (v) # Los argumentos de la función se escriben
encerrados entre paréntesis y separados por comas
{ med <- mean(v);} # El cuerpo de la función se encierra entre llaves. Y si son des <- sd(v); varias las operaciones a realizar se separan con puntos c(med, des)} y comasCuando la función devuelve el resultado, los objetos ‘med’ y ‘des’ dejan de estar definidos.
Estructuras de programación: R permite crear estructuras repetitivas (loops) y la ejecución condicional de sentencias. A este fin, los comandos pueden agruparse entre llaves, utilizando la siguiente sintaxis:
{comando1 ; comando2; comando3 ; ....}
El bucle for: Para crear un bucle repetitivo (un bucle for), la sintaxis es la siguiente:for (i in listadevalores) { secuencia de comandos }
No obstante, los bucles for son lentos en R (y en Splus), y deben ser evitados en la medida de lo posible.
El bucle while: La sintaxis es como sigue:while ( condicion logica) { expresiones a ejecutar }
La ejecución condicional if: La sintaxis general es:if (condicion) comando1 else comando2
Alcance de las variables. Las variables definidas dentro del cuerpo de una función son locales, y desaparecen al terminar la ejecución de la función. Por ejemplo:
> y <- 10 # Definimos la variable y > cuadrado <- function(x){ y <- x^2 ; return(y)} # Definimos otra y local > x<-2 # Asignamos valor a x > cuadrado(x) # Calculamos el cuadrado de x : Se hace y=4 (localmente) [1] 4 > y # Sin embargo, y no ha cambiado. La y local desaparece [1] 10
Funciones con un número variable de argumentos. En R es posible definir funciones con un número variable de argumentos. Para ello, la sintaxis es:
f <- function(x, ...) { cuerpo de la función }
f <- function(...,x) { cuerpo de la función }
En el primer caso, la función podría llamarse sin hacer referencia explícita a x (por ejemplo f(2) ).En el segundo caso deberíamos especificar f(x=2), dado que el sistema, al encontrar primero los argumentos variables, no podría saber si nos estamos refiriendo a x o a uno de los argumentos variables.
Vamos a poner un ejemplo en dos fases. En primer lugar, para entender como funciona al tema, definiremos una función que simplemente devuelve sus argumentos:
> f<-function(...){ L <- list(...) ; return(L)}> f(1,2,3)
[[1]][1] 1[[2]][1] 2[[3]]
17
[1] 3> f(c(1,2),c(3,4,5)) # Así pues, tan vble es el nº de arg., como el nº
[[1]] # de elementos de cada uno.[1] 1 2[[2]][1] 3 4 5
Vamos a aprovechar esta facilidad para definir una función que devuelva algunas medidas resumen de las distribuciones que se le pasen como argumento. La entrada a la función será una serie de conjuntos de datos, y la salida la media, varianza, mínimo y máximo de cada uno de los conjuntos.f <- function(...){datos <- list(...)medias <- lapply(datos,mean) # lapply aplica una función varianzas <- lapply(datos,var)# sobre una listamaximos <- lapply(datos,max)minimos <- lapply(datos,min)for(i in 1:length(datos)){cat("Distribución ",i,": \n") # La función cat es para visualizar cosascat("media: ", medias[[i]], "varianza: ", varianzas[[i]], "maximo: ",maximos[[i]],"minimo: ",minimos[[i]],"\n")cat("------------------------------------------------\n")}}Veamos un ejemplo sencillo:
> f(c(1,2),c(1,3,5,7),c(-1,2,-5,6,9))
Distribución 1 :media: 1.5 varianza: 0.5 maximo: 2 minimo: 1------------------------------------------------Distribución 2 :media: 4 varianza: 6.666667 maximo: 7 minimo: 1------------------------------------------------Distribución 3 :media: 2.2 varianza: 30.7 maximo: 9 minimo: -5------------------------------------------------
# La familia apply.
Cada vez que vayamos a usar un “bucle” intentemossubstituirlo por algún miembro de familia apply.
# Las funciones sapply(X, función) y lapply(X, función) son como apply(x,i,función) (Ver pág 11) pero no hay que especificar el índice i=1 (filas),2 (columnas).Las funciones lapply y sapply aplican una misma función a cada uno de los elementos de un vector o lista (esto incluye las columnas de un marco de datos). La función lapply siempre devuelve una lista con los resultados. La función sapply intenta devolver el tipo de dato más simple posible (la “s” es de “simplify”).
La función tapply(x,y, función) calcula la función especificada sobre el objeto x según las categorías de y.> x <- c(19,14,15,17,20,23,19,19,21,18)> trat <- c(rep("A",5),rep("B",5))> x.media <- tapply(x,trat,mean)> x.media
# La función by aplica una misma función a los submarcos de datos formados por las filas del marco de datos dado como entrada que pertenecen a una misma categoría del factor especificado.Modo de uso:
by(MARCO DE DATOS, FACTOR, FUNCIÓN)by(MARCO DE DATOS, LISTA DE FACTORES, FUNCIÓN)
# La función aggregate actúa como tapply para cada columna del marco de datos dado como entrada.Modo de uso:
aggregate(MARCO DE DATOS, LISTA DE FACTORES, FUNCIÓN)
18
9. LECTURA DE MARCOS DE DATOS DESDE FICHEROS
# Primer formato de fichero (TXT):
Todas las filas incluidas en el fichero tienen el mismo número de elementos, SALVO LA PRIMERA, que tiene un elemento menos.
La primera fila contiene los nombres de las variables del marco de datos. El resto de filas contienen como primer elemento el nombre de la fila y como resto de elementos los datos correspondientes.
Los datos están separados por espacios en blanco. En los números los decimales vienen indicados por un
punto. Los valores desconocidos se expresan con NA.
Cuando un fichero de datos se encuentre escrito en el formato indicado arriba, se utiliza la función read.table para leerlo y obtener un marco de datos.
La función count.fields resulta de utilidad a la hora de comprobar si se cumplen las condiciones acerca del número de elementos de la primera fila y de las restantes.
coches1 <- read.table("coches.txt")count.fields("coches.txt")
Sea "lbw.csv" la BD guardada en el formato TXT, entonces se pordrá cargar sus datos en R, indicándole además que conserve los nombres de las variables, ejecutando el comando:
> data1 <- read.csv("C:/data/lbw.txt", header=T)> attach(data1)
Si queremos editar algún dato de nuestro data.frame "data1" no es necesario volver a cargar los datos, pues puedo editarlo a través de la barra de menús:
19
Editar>Editor de datos... e indicar el nombre del marco de datos que deseamos editar, en nuestro caso "data1”. O bien, ejecutando
> fix(data1) el cual nos abre una tabla en la que podemos editar los datos del marco de datos cargado en memoria.
# Segundo formato de fichero (CSV - versión inglesa):
La primera fila contiene los nombres de las variables del marco de datos. El resto de filas contienen los datos correspondientes.
Las filas que tengan menos elementos que la más larga son completadas con valores NA.
Los datos están separados por comas. En los números los decimales vienen indicados por un
punto. Los valores desconocidos se expresan con NA.
Estos ficheros se leen utilizando la función read.csv, que proporciona un marco de datos.
Sea "lbw.txt" la BD guardada en el formato CSV, entonces se pordrá cargar sus datos en R, indicándole además que conserve los nombres de las variables, ejecutando el comando:
> data2<- read.csv("C:/data/lbw.csv", header=T)> attach(data2)
Una alternativa para evitar poner la ruta completa del fichero en el que se encuentran los datos, el ir al fichero de origen, seleccionar con el ratón el rango de datos que se desea cargar en R y copiarlo en el portapapeles (clipboard).
Finalmente, ejecutando el comando siguiente R leerá el conjunto de datos guardados en el portapapeles.
> data3 <- read.table("clipboard")
O incluso, ejecutando el siguiente comando:
> ruta <- file.choose() ## Abre la ventana "Seleccionar archivo" para coger la ruta del fichero a seleccionar. Y a continuación, sólo habrá que ejecutar:> data4<- read.csv(ruta, header=T)
Otra función que R utiliza para importar archivos de tipo texto es read.table.read.table(archivo,header=FALSE,sep="",dec=".",na.strings="NA")En esta línea:
archivo sería el nombre del archivo que queremos importar. Opcionalmente, se puede importar desde el portapapeles, en ese caso, el valor debe ser "Clipboard".
header puede tomar el valor TRUE, si sabemos que la primera línea del archivo (cabecera) contiene los nombres de las variables, o el valor FALSE, si no lo hace.
sep se refiere al carácter que separa los datos. En nuestro ejemplo son tabulaciones, luego deberemos poner “\t”. El valor por defecto es vacío, que corresponde a uno o más espacios en blanco o a tabulaciones.
dec se refiere al carácter que separa los números decimales. Hay que tener cuidado con él porque en español lo correcto es separar con comas, pero en el mundo anglosajón lo es hacerlo con puntos. De hecho, el punto es la opción por defecto.
na.strings se refiere al carácter que en el archivo original identifica a los datos faltantes. Por defecto, se supone que un dato faltante aparecerá como “NA”, pero podemos poner cualquier otro. Si el dato faltante simplemente no aparece en el archivo original, será entendido como tal dato faltante sin necesidad de especificar nada más.
# Segundo formato de fichero (CSV - versión española):
20
La primera fila contiene los nombres de las variables del marco de datos. El resto de filas contienen los datos correspondientes.
Las filas que tengan menos elementos que la más larga son completadas con valores NA.
Los datos están separados por punto y comas. En los números los decimales vienen indicados por una
coma. Los valores desconocidos se expresan con NA.
Estos ficheros se leen utilizando la función read.csv2, que proporciona un marco de datos.
# Tercer formato de fichero (XLS)
Si se desea cargar los datos contenidos en una hoja determinada de Excel, se deberá usar la librería "RODBC". Por ello, si no disponemos de esta librería, primero habrá que instalarla.
> install.packages("RODBC")Y para usarla habrá que cargar dicha librería> library("RODBC")
Open DataBase Connectivity (ODBC) es un estándar de acceso a Bases de datos que utilizan los sistemas Microsoft. Para conectar con ODBC una base de datos se ha de crear un DSN, que es un nombre que asociamos a una conexión por ODBC para referirnos a ella desde las aplicaciones o programas que deban conectarse con la base de datos.
Cualquier base de datos que se pretenda utilizar desde aplicaciones Windows debe tener su propio driver ODBC. Por ejemplo, MySQL dispone de un Driver ODBC que se puede descargar desde su página web. Las bases de datos Access (Microsoft Jet) y SQL Server de Microsoft también tienen su driver ODBC y este ya se encuentra instalado en el Windows de fábrica.
Lo que vamos hacer es abrir una conexión entre R y en este caso con Excel a través del comando odbcConnectExcel(). Y para ello, vamos a crear un nombre del canal para dicha conexión
> canalexcel<- odbcConnectExcel("C:/data/lbw.xls")
En el caso de disponer un fichero en el formato de Excel de 2007 “lbw.xlsx” se debería usar el comando odbcConnectExcel2007() de la misma forma.
Para pedirle a R que lea el contenido del libro de Excel se usa el comando siguiente:
> sqlTables(canalexcel) # La salida de de este comando nos muestra una tabla, con tantas filas como hojas tenga dicho libro, y nos muestra como están nombradas dichas hojas.
Para ver el contenido de una hoja determinada, por ejemplo, para ver el contenido de la hoja "PAS" se usará el comando
> sqlFetch(canalexcel, "PAS")
Pero como con el simple resultado de este comando no podemos trabajar, se guardará su resultado en una variable
> datos <- sqlFetch(canalexcel, "PAS")
Y como ya no se necesitará más usar el canal de Excel, se procederá a cerrar a través de
> odbcClose(canalexcel)
Por último, otra forma para poder leer BD de Excel, es usando la librería "gdata"
> library(gdata)
21
Y en dicha librería podrá encontrar el comando read.xls que es más complicado que los procedimientos anteriores. Más información en:
http://cran.r-proyect.org/web/packages/gdata/gdata.pdf
10. 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 = "xy.RData")
Los leeremos con
> load("xy.RData")
Podemos guardar todos los objetos con
> save.image() # guardado como ".RData"> save.image(file = "nombre.RData")
El fichero .RData se carga al iniciarse R. R y muchos otros paquetes incorporan archivos con datos: Se cargan con load("nombre.RData").
La instrucción data permite cargar archivos de las librerías disponibles.> data() # muestra todos los archivos> data(iris)> data(iris, package = "base") # equivalente> ?iris
22
11. EXPORTAR DATOS
Lo más sencillo es exportar una matriz (es necesario transponer la matriz).
> write(t(x), file = "c:/dir/data.txt",+ ncolumns = n,+ append = FALSE)
Pero para exportar un data.frame es mejor
> write.table(my.data.frame,+ file = "mi.output.txt",+ sep = "",row.names = FALSE,+ col.names = TRUE)
Para escribir un fichero CSV importable desde Excel
> write.table(x, file = "foo.csv", sep = ",",+ col.names = NA)
12. ATRIBUTOS DE OBJETOS
Modo: Tipo básico en un vector o array: lógico, entero, real, carácter, ...: 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 alfanumérico con la lista de las clases del
objeto: classCada objeto pertenece a una clase, y ello permite utilizar en R programación dirigida a objetos.Por ejemplo, si un objeto pertenece a la clase "data.frame", se imprimirá de un modo especial; cuando le aplique la función plot() ésta mostrará un gráfico de un tipo especial; y otras funciones genéricas, como summary(), producirán un resultado especial; todo ello en función de la pertenencia a dicha clase.
Otros: atributos de una serie temporal.
# Atributos intrínsecos: modo y longitud
Todo objeto tiene dos atributos intrínsecos: modo y longitud. El modo se refiere a la clase básica de los elementos en el objeto; existen cuatro tipos principales: numérico, carácter, complejo, y lógico (FALSE [Falso] or TRUE [Verdadero]). Existen otros tipos, pero no representan datos como tal (por ejemplo funciones o expresiones). La longitud es simplemente el número de elementos en el objeto. Para ver el tipo y la longitud de un objeto se pueden usar las funciones mode y length, respectivamente:
23
Los vectores pueden ser numéricos, complejos, de caracteres y lógicos.
mode(1:5) # Vector numérico.mode(c(1.1, -2.25)) # Vector numérico.mode(c(0+1i, 0-1i)) # Vector complejo.
Técnicamente, el primero es un vector de enteros y el segundo un vector de números reales (con doble precisión).
mode(c("uno","dos","tres")) # Vector de caracteres.mode(1:5 >= 3) # Vector lógico.
# Valores Perdidos: Cuando un dato no está disponible se representa como NA (del inglés ’not available’) independientemente del tipo del dato.
NA es el código de "Not available". Es un valor lógico que es usado como indicador de los valores perdidos.
v <- c(1,6,9,NA)is.na(v) <- FALSE FALSE FALSE TRUEwhich(is.na(v)) <- 4w <- v[!is.na(v)] # sin los valores perdidosv == NA # !No funciona! ¿Por qué?
Sustituir NA por, p.ej., 0:
v[is.na(v)] <- 0
Los valores NA pueden dar problemas con algunas funciones:
xna <- c(1, 2, 3, NA, 4); mean(xna) <- [1] NAmean(xna, na.rm = TRUE) <- [1] 2.5
# Todos los elementos de un vector deben ser del mismo modo, con la única excepción del objeto NA.
NA es de modo lógico. Es el código de “Not available”.mode(NA) <- "logical"c(1, NA, 3)
mode(c(1, NA, 3)) <- "numeric"
Los arrays son vectores.mode(matrix(1:6, 2, 3)) <- "numeric"typeof(matrix(1:6, 2, 3)) <- "integer"mode(array(c("a", "b", "c"), c(1, 1, 3))) <- "character"
Las listas y los marcos de datos son de modo lista.mode(list(nombre = "Yo", edad = 80)) <- "list"typeof(list(nombre = "Yo", edad = 80)) <- "list"mode(data.frame(peso = c(70, 80), genero = c("F", "M")))
Las funciones son de tipo function.mode(sum) <- "function"
El objeto NULL es de modo nulo.mode(NULL) <- "NULL"
R representa correctamente valores numéricos no-finitos como ± con Inf y -Inf, o valores que no son numéricos (indeterminaciones) con NaN (del inglés ’not a number’). El infinito y NaN (“not a number”) son diferentes de NA.
5/0; -5/0; 0/0 <- Inf ; -Inf ; NaNis.infinite(-5/0); is.nan(0/0); is.na(5/0) <- TRUE, TRUE, FALSE
# Para comprobar el modo de un atributo, lo conveniente es usar las funciones de tipo is.modo.
is.numeric(1:5)is.numeric(c("uno", "dos"))is.list(list(a = 1, b = "dos"))is.null(NULL)is.null(5.5)
# Podemos cambiar el modo de un objeto directamente.
v <- 1:5mode(v)mode(v) <- "character"v
24
mode(v) <- "complex"vmode(v) <- "numeric"v
# Pero es más conveniente hacerlo con las funciones de tipo as.modo.as.character(v)as.complex(v)as.list(v)
No siempre es posible cambiar a un modo determinado.as.function(v)
# Para simplificar una lista es conveniente usar la función unlist.list(a = "a", b = 2, c = pi+2i)unlist(list(a = "a", b = 2, c = pi+2i))list(a = list(x = 1:5, y = LETTERS[1:5]), b = "Z", c = NA)unlist(list(a = list(x = 1:5, y = LETTERS[1:5]), b = "Z", c = NA), recursive = T)unlist(list(a = list(x = 1:5, y = LETTERS[1:5]), b = "Z", c = NA), recursive = F)
# R está siempre pendiente de cambiar el modo de un objeto al más sensato para aplicar una determinada función.sum(c(T, T, F, T))
Aunque a veces no sabe o no puede.sum(c("a", "b"))sum(c("1", "2"))
# El modo es un atributo intrínseco de todo objeto. Además, estos poseen otro atributo intrínseco: la longitud.length(v)length(list(a = 1, b = "dos"))
Los números y cadenas son vectores de longitud 1.mode(5.7)length(5.7)mode("hola")length("hola")
Es posible crear vectores de longitud determinada, incluso 0.complex(5)complex()character(3)character()# Éste es un vector de caracteres vacíonumeric(0) # Éste es un vector numérico vacío
# La función ls devuelve un vector de cadenas con los objetos definidos en el entorno global. Por eso, cuando no hay objetos definidos aparece character(0); es decir, un vector de caracteres de longitud 0.
# Atributos no intrínsecos de un objeto
# Para mostrar una lista de todos los atributos no intrínsecos definidos para el objeto en ese momento se usa la función attributes.
v <- 1:6names(v) <- letters[1:6]vattributes(v)
# Podemos cambiar o eliminar los atributos de un objeto.attributes(v) <- NULL
vattributes(v) <- list(dim = c(2, 3), dimnames = list(letters[1:2], letters[1:3]))v
# La función attr(objeto, nombre) puede usarse para seleccionar o cambiar un atributo específico. Estas funciones no se utilizan habitualmente, sino que se reservan para la creación de un nuevo atributo con fines específicos, por ejemplo, para asociar una fecha de creación o un operador con un objeto de R. Sin embargo, es un concepto muy importante que no debe olvidar.
25
La asignación o eliminación de atributos de un objeto debe realizarse con precaución, ya que los atributos forman parte del sistema de objetos utilizados en R.
v <- 1:6names(v) <- letters[1:6]vattr(v, "names")attr(v, "names") <- LETTERS[1:6]v
# Es mejor usar las funciones específicas para cambiar los atributos. Por ejemplo, mejor.
dim(v) <- c(2, 3)v
queattr(v, "dim") <- c(3, 2)v
# Mediante el uso de atributos se pueden extender los tipos de datos básicos. Por ejemplo, un array es un vector que tiene definido el atributo dim. Para estos tipos de datos extendidos también existen funciones del tipo is.tipo y as.tipo.
# Un atributo muy importante, al ser R un lenguaje orientado a objetos, es el atributo class. Este permite establecer distintos comportamientos de una misma función atendiendo a la clase del objeto recibido como argumento.v <- c(1:6, 1:3)vmode(v) # Es un vector numérico.attr(v, "class") # El atributo class no está definido.summary(v)
f <- cut(v, breaks = c(1, 3, 6), include.lowest = T)fmode(f) # Sigue siendo un vector numérico.attr(f, "class") # El atributo class, entre otros, sí está definido.summary(f)
# Es posible definir cualquier atributo que se nos ocurra. Algunos modificarán el comportamiento de las funciones de R. Otros solo nos serán de utilidad a nosotros.v <- 1:10vattr(v, "fecha") <- "23 de Octubre"attr(v, "comentario") <- "vector de ejemplo"v
13. MANEJO DE DATOS
# Manejo de datos: Recodificación de una variable
Recodificar una variable consiste en construir una nueva variable mediante la transformación de los valores de otra variable.
En la sintaxis de la función recode(), incluida en el paquete car debemos especificar cuál es la variable a recodificar, cuáles son los criterios de recodificación y si deseamos que la nueva variable resultante de la recodificación sea un factor o no.
library(car) #Para cargar el paqueteDatos$Provincia<-recode(Datos$ine, "14000:14999='Córdoba' ; 23000:23999='Jaén'", as.factor.result=TRUE)
En primer lugar hemos escrito el nombre de la nueva variable, Provincia. Como queremos que sea una nueva variable de la hoja de datos Datos, hemos escrito Datos$Provincia.
Como primer argumento de recode() hemos escrito la variable que vamos a recodificar, Datos$ine.
A continuación hemos especificado los criterios de recodificación. Deben estar siempre entre comillas. Si hay más de uno, que es lo más habitual, deben estar separados por puntos y comas. Finalmente, los nombres de los niveles de las variables recodificadas deben estar entre comillas simples.
26
En el ejemplo queremos que todos los códigos entre 14000 y 15000 sean asignados a Córdoba. Escribir 14000:14999 es una forma rápida de generar el vector con todos los enteros entre 14000 y 14999. Así, el primer criterio de recodificación es 14000:14999='Córdoba'.
Finalmente, as.factor.result=TRUE indica que la nueva variable Provincia será un factor.
Si se desea recodificar una variable tipo carácter, es igual al caso anterior con la salvedad de que los valores de la variable cualitativa o de tipo carácter deben escribirse entre comillas en las instrucciones para la recodificación.
Mediante R Commander, 1º importamos el archivo. A continuación seleccionamos la opción Datos → Modificar variables del conjunto de datos activo → Recodificar variables. Y nos aparecerá la ventana en la ya están incluidas las entradas necesarias para nuestra recodificación.
# Manejo de datos: Cálculo de nuevas variables
Supongamos un data.frame (Datos) con 2 variables: V1 y V2. Y queremos obtener una tercera variable que sea la suma de las dos. Recordemos que para referirnos a una variable de una hoja de datos debemos escribir primero el nombre de la hoja de datos, seguido del símbolo $ y del nombre de la variable. Se calcula de la siguiente forma:Datos$Suma <- Datos$V1 + Datos$V2Lo que R hace es sumar elemento a elemento los datos correspondientes a cada fila. Desde luego, hay una forma mucho más fácil:Datos$Suma <- rowSums(Datos[,1:2])Lo que se hace es sumar por filas, todas las variables, de la 1ª a la 2ª.
En general, podemos realizar las operaciones aritméticas habituales (suma, diferencia, multiplicación, división, potencias, etc.), con la notación matemática propia de estas operaciones,
sin olvidar que tales operaciones se realizan elemento a elemento sobre todos y cada uno de los elementos que constituyen cada variable de la hoja de datos.
Mediante R Commander, 1º importamos los datos. A continuación seleccionamos la opción del menú Datos → Modificar variables del conjunto de datos activo → Calcular una nueva variable.
# Manejo de datos: Filtrado de datos
En ocasiones es necesario analizar, no todo el conjunto de datos, sino sólo un subconjunto de éste. En ese caso, lo que se hace es filtrar los datos mediante alguna condición dada por uno o varios valores de alguna variable.
Por ejemplo, supongamos que en el archivo de datos contenido en JaenCordoba.xls deseamos analizar sólo los datos de los municipios de Jaén.
No olvidemos que la forma de referirnos a los elementos de una variable que conocemos hasta ahora es poniendo la posición que ocupan entre corchetes. Ahora vamos a hacer algo parecido, pero escribiendo entre los corchetes la condición que determina el filtro.
Siguiendo con el ejemplo, algunas formas de filtrar los datos de los municipios de Jaén son:Datos.Jaen <- Datos[Datos$Provincia=="Jaén",]Datos.Jaen <- Datos[(Datos$ine>23000)&(Datos$ine<24000),]
No perdamos de vista que al no poner nada tras la coma que hay dentro del corchete estamos pidiendo a R que mantenga todas las variables.
En resumen, el filtrado se logra identificando las filas que deseamos conservar mediante una expresión lógica. Nótese
27
también que aquí lo que estamos generando es otro data.frame pero ya filtrado.
Mediante R Commander, 1º importamos los datos. A continuación seleccionamos la opción del menú Datos → Conjunto de datos activo → Filtrar el conjunto de datos activo.
14. RESÚMENES NUMÉRICOS
# Tablas de frecuencias para variables categóricas
Hemos visto que un factor es un vector utilizado para especificar una clasificación discreta de los elementos de otro vector de igual longitud.
En R existen dos tipos de factores (variables categóricas): Nominales: No existe jerarquía entre ellos (p.e. colores) Ordinales: Existe jerarquía entre ellos (p.e. grupos de
edad)
La función table() calcula la tabla de frecuencias a partir de factores de igual longitud.
Si existen k argumentos categóricos, el resultado sería una variable k-indexada, que contiene la tabla de frecuencias.
> x <- as.factor(1:5); table(x)x1 2 3 4 5 1 1 1 1 1
# Medidas de localización, dispersión y forma para vbles cuantitativas cont.
La forma más sencilla de empezar a describir unos datos cuantitativos es realizar un resumen estadístico. A continuación
mostramos un listado de las más habituales para describir la localización y la dispersión.
Función Utilidadsum(..., na.rm=FALSE) ----------->Sumamax(..., na.rm=FALSE) ----------->Máximomin(..., na.rm=FALSE) ----------->Mínimowhich.max(x) -------------------->Posición del máximowhich.min(x) -------------------->Posición del mínimopmax(..., na.rm=FALSE) ---------->Máximo en paralelopmin(..., na.rm=FALSE) ---------->Mínimo en paralelocumsum(x), cumprod(x) ----------->Sumas y prods acumuladoscummax(x), cummin(x) ------------>max's y min's acumuladosmean(x, trim=0, na.rm=FALSE) ---->Mediaweighted.mean(x,w,na.rm=FALSE)--->Media ponderadamedian(x,na.rm=FALSE)) ---------->Medianaquantile(x,prob=(0, 0.25, 0.5, -->Cuantiles 0.75, 1), na.rm=FALSE) fivenum(x, na.rm=FALSE) --------->5-Turkey: min, lower-hinge, mediana, upper-hinge, máximosummary(x, na.rm=FALSE) --------->min, 1c, mediana, media, 3c, máxIQR((x, na.rm=FALSE) ------------>Rango inter-cuartílicorange(..., na.rm=FALSE), -------->Rango finite=FALSE) var(s, y=x, na.rm=FALSE, use) --->Varianzasd(x, na.rm=FALSE) -------------->Desviación Típicamad(x, center, constant=1.4426, ->Desviación mediana absoluta na.rm=FALSE)
A continuación mostramos algunos ejemplos de sus usos:
x<- rgamma(50,1,3)summary(x) Min. 1st Qu. Median Mean 3rd Qu. Max. 0.007676 0.123300 0.273100 0.360800 0.533100 1.932000 fivenum(x)[1] 0.007676408 0.121071202 0.273148458 0.546166224 1.931585638mean(x) # Devuelve [1] 0.3607868median(x) # Devuelve [1] 0.2731485quantile(x) # Devuelve 0% 25% 50% 75% 100%
28
0.007676408 0.123261740 0.273148458 0.533118606 1.931585638 quantile(x, c(0.35, 0.9)) # Devuelve: 35% 90% 0.1823805 0.6812816 sd(x) # Devuelve [1] 0.3425493var(x) # Devuelve [1] 0.1173401range(x) # Devuelve [1] 0.007676408 1.931585638IQR(x) # Devuelve [1] 0.4098569min(x) # Devuelve [1] 0.007676408which.min(x) # Devuelve [1] 25x[which.min(x)] # =min(x). Devuelve [1] 0.007676408x[1:5]; x[6:10][1] 0.30707224 0.26695446 0.06652911 0.09481880 1.13773193[1] 0.1634702 0.9626096 0.4939758 0.5660164 0.5574238pmin(x[1:5], x[6:10]) # Devuelve [1] 0.16347017 0.26695446 0.06652911 0.09481880 0.55742379
Para analizar la curtosis y la asimetría de unos datos podemos utilizar dos funciones de la librería e1071; el coeficiente de asimetría skewness(x, na.rm = FALSE, type = 3) y kurtosis().Si x contiene valores perdidos y éstos no se eliminan, la asimetría (skewness) es NA.
Sea el momento de la muestra de orden r .
Joanes y Gill (1998) analizan tres métodos para estimar la asimetría:
Tipo 1 : . Esta es la definición típica usada en
muchos libros de texto más antiguos.
Tipo 2 : . Utilizado en SAS y SPSS.
Tipo 3 : . Utilizado en MINITAB y
BMDP.
> library(e1071) # Loading required package: class> moment(x,2,center=F) # momento no centrado de orden 2[1] 0.2451603
Consideremos dos distribuciones asimétricas (Betas) y las vamos a comparar con la normal que es simétrica:nsim <- 5000s1 <- skewness(rbeta(nsim,2,3))s2 <- skewness(rbeta(nsim,3,2))s3 <- skewness(rnorm(nsim,0.5,0.5))s1; s2; s3
Consideraremos ahora una distribución normal y una Student, más achatada, y las comparamos:k1 <- kurtosis(rnorm(nsim))k2 <- kurtosis(rt(nsim,3))k1; k2
También cargando la libreria “moments” podemos usar las funciones:
library(moments)skewness(datos)kurtosis(datos)
29
15. ELEMENTOS GRAFICADORES EN R
R ofrece una increíble variedad de gráficos con un gran número de opciones que permiten una enorme flexibilidad.
Para poder crear gráficos es necesario inicializar un dispositivo gráfico (graphic device), y si hay varios, elegir uno de ellos. De hecho, al ejecutarse una función gráfica, R abre una ventana para mostrar el gráfico si no hay ningún dispositivo abierto.
El resultado de una función gráfica no puede ser asignado a un objeto sino que siempre es enviado a un dispositivo gráfico, los cuales se abren invocando a la función correspondiente.
El tipo de dispositivos gráficos disponibles depende del sistema operativo.
Las ventanas gráficas se llaman X11 bajo Unix/Linux, windows bajo Windows y macintosh bajo Mac.
En Unix/Linux y Windows se puede abrir una nueva ventana gráfica con el comando x11() ya que en Windows existe un alias apuntando a windows(). Dispositivos gráficos que son archivos se pueden abrir con una función que depende del tipo de archivo que se quiere crear: postscript(), pdf(), png(), . . .Los primeros son ventanas (X11(), windows()) y los segundos archivos (postscript(), pdf(), png(),...)
Pueden abrirse varios dispositivos de los cuales tan sólo uno de ellos será el activo. La lista de dispositivos gráficos disponibles se obtiene con el comando ?device.
El último dispositivo en ser abierto, se convierte en el dispositivo activo sobre el cual se dibujan (y se enviará todas) las gráficas generadas. La función dev.list() muestra una lista con los dispositivos abiertos:> x11(); x11(); pdf()
> dev.list()X11 X11 pdf2 3 4Los números corresponden al número del dispositivo respectivo. Este se puede usar para cambiar el dispositivo activo. Para saber cual es el dispositivo activo usamos la función dev.cur(), que devolvería pdf (4), y para cambiar el dispositivo activo utilizamos el comando dev.set():> dev.set(3)X113La función dev.off() por defecto se cierra el dispositivo activo, de lo contrario el correspondiente al número pasado en la función. R muestra el número del nuevo dispositivo activo:> dev.off(2)X113> dev.off()pdf4Vale la pena mencionar dos características específicas de la versión de R para Windows: 1) la función win.metafile abre un dispositivo meta-archivo de Windows , y 2) el menú “History” seleccionado cuando la ventana gráfica está activa, permite ‘grabar’ todas las gráficas durante una sesión (por defecto, esta opción está inactiva, pero el usuario la puede activar haciendo click en “Recording” en este menú).
30
# Disposición de una gráfica
La función split.screen divide el dispositivo gráfico activo. Por ejemplo:> split.screen(c(1, 2))divide el dispositivo en dos partes que se pueden seleccionar con screen(1) o screen(2); erase.screen() borra la última gráfica dibujada. Una parte de un dispositivo se puede dividir a su vez en partes más pequeñas con split.screen() permitiendo la posibilidad de configuraciones complejas.
Estas funciones son incompatibles con otras similares (como layout() o coplot()) y no se deben usar con múltiples dispositivos gráficos. Su uso se debe limitar por ejemplo, a la exploración gráfica de datos.
La función layout divide el dispositivo activo en varias partes donde se colocarán las gráficas de manera sucesiva. Esta función tiene como argumento principal una matriz con números enteros indicando el número de las sub-ventanas. Por ejemplo, para dividir el dispositivo en cuatro partes iguales:> layout(matrix(1:4, 2, 2))
También es posible crear esta matriz previamente permitiendo una mejor visualización de la manera como se va a dividir el dispositivo:> mat <- matrix(1:4, 2, 2)> mat[,1] [,2][1,] 1 3[2,] 2 4> layout(mat) # Crea la división en el dispositivo gráfico>layout.show(4) # Visualiza la partición creada
Además podemos combinar celdas (o subventanas) repitiendo el número de la primera subventana que deseamos combinar en las celdas que queremos que permanezcan unidas a la primera.
>m <- matrix(c(1:3, 3), 2, 2)
> m [,1] [,2][1,] 1 3[2,] 2 3>layout(m)>layout.show(3)
Nótese que al no haberse usado la opción byrow de matrix() (leer por filas),las subventanas se han numerado a lo largo de las columnas. Sin embargo, se puede especificar matrix(..., byrow=TRUE) para numerar las subventanas a lo largo de las filas.
Por defecto, layout() divide el dispositivo en dimensiones regulares: esto se puede modificar con las opciones widths y heights. Estas dimensiones se dan de manera relativa (aunque pueden ser proporcionadas en centímetros, ver ?layout). >m <- matrix(1:4, 2, 2) >layout(m, widths=c(1, 3),heights=c(3, 1))>layout.show(4)
>m <- matrix(c(1,1,2,1),2,2)>layout(m, widths=c(2, 1),heights=c(1, 2))>layout.show(2)
Finalmente, los números en la matriz pueden ser ceros dando la posibilidad de realizar arreglos complejos.>m <- matrix(0:3, 2, 2)>layout(m, c(1, 3), c(1, 3))>layout.show(3)
31
Para representar variables categóricas o cuantitativas discretas (con pocas clases)
La función par(mforw=c(a,b)) permite dividir la pantalla gráfica en una matriz de gráficos de dimensión a x b. Si queremos volver a la situación anterior de pantalla completa, deberemos ejecutar par(mforw=c(1,1))
R tiene dos sistemas de producir gráficos: El tradicional, que es el que veremos principalmente. Graficos Trellis (paquete Lattice) del que veremos algunos
ejemplos.
Las funciones gráficas en R son de tres tipos: Funciones de alto nivel: crean un nuevo gráfico de un
tipo ya definido, posiblemente con ejes, etiquetas, títulos, etc.
Funciones de bajo nivel: añaden información a un gráfico ya existente (punto adicionales, líneas, etiquetas,...)
Funciones interactivas: permiten añadir o extraer información de un gráfico utilizando el ratón
# Gráficos de alto nivel (son los que crean una nueva gráfica)
Entre las funciones de alto nivel para dibujar, podemos destacar por su frecuencia de uso las siguientes:
barplot : Diagrama de barraspie : Diagrama de sectoresdotchart : Gráfico de puntos
x <- rbinom(100,5,0.3)x.frec <- table(x) ; x.frec#Devuelve: x# 0 1 2 3 4 5 # 16 39 29 10 5 1par(mfrow=c(2,2))barplot(table(x))barplot(table(x),col=rainbow(length(table(x))))pie(table(x))
boxplot : Diagrama de cajastem : Diagrama de tallo y hojashist: Histograma
plot : Rutina de dibujo generalEl comando plot se utiliza para crear una nueva figura. Por ejemplo:
x = seq(-10,10) # Generamos los números -10, -9,....,9, 10y = x^2 # Generamos los cuadrados de dichos númerosplot(x,y) # Dibuja el gráfico de la parábola x^2
contour: Gráfico de contornopairs: Pares de gráficos de dispersión por variablespersp: gráficos 3D
# Gráficos de bajo nivel (los que agregan elementos a una gráfica ya existente)
Los comandos de bajo nivel sirven para añadir información extra a los gráficos que producen los comandos de alto nivel. Por ejemplo, podríamos querer añadir texto a un gráfico, puntos extras, líneas, cosas así. Entre los más importantes podemos destacar:
points(x,y) Añade puntos o líneas conectadas al gráfico actuallines(x,y)
text(x,y,etiquetas) Añade texto al gráfico actual en la posición x,y
abline(a,b) Añade una línea de pendiente a y que corta al origen en b.
abline(h=y) Añade línea horizontal que corta al eje y en h=yabline(v=x) Lo análogo para línea vertical
polygon(x,y) Dibuja un polígono
32Para representar datos continuos
title(main,sub) Añade título y subtítulo al gráfico actual
axis(side) Añade ejes al gráfico actual (de 1 a 4)
# Funciones interactivasEn R existen una serie de funciones que permiten completar los gráficos de manera interactiva por parte del usuario.
locator() devuelve las coordenadas de los puntos. Sitúa el cursor en la ventana de gráficos, cada vez que pulsemos el botón izquierdo del mouse nos devolverá las coordenadas del punto en el que hayamos marcado.identify(x, y, etiquetas) identifica los puntos con el ratón y escribe la correspondiente etiqueta. Nos permite marcar uno de los puntos del gráfico (con el ratón, igual que antes), y nos devuelve la componente de los vectores representados que dio lugar a ese punto. Muy útil en estadística para identificar outliers.
x <- (0:65)/10; y <- sin(x); z <- cos(x)> plot (x,y,main="Funciones seno y coseno", type="l")> lines(x,z, col=2, lty=2)> legend(locator(1), legend=c("sin(x)", "cos(x)"), lty=c(1,2), col=c(1,2))
x <- 1:10; y<- sample(1:10)nombres <- paste("punto", x, ".", y, sep="")plot(x, y); identify(x, y, labels = nombres)
# Algunos Parámetros para Graficar en R
Todas las funciones gráficas que se explican a continuación admiten los siguientes parámetros:
data = un marco de datos que contiene las variables con los valores a partir de los cuales se construye el gráfico.
horizontal = valor lógico que determina, cuando tenga sentido, si el gráfico debe dibujarse horizontal o verticalmente.
main = título principal del gráfico. sub = ’título de abajo’ (subtítulo secundario del gráfico) type =’< l | p | b | n >’ Línea, puntos, ambos, ninguno lty = n Tipo de Línea lwd = Cambia el grosor de línea pch=’.’ Caracter de dibujo xlab, ylab = etiquetas de los ejes x e y. xlim, ylim = límites de los ejes x e y.
xlim=c(xminimo; xmaximo) ó xlim=range(x)ylim=c(yminimo; ymaximo)
33
# Conjuntos de datos
Los paquetes de R suelen proporcionar distintos conjuntos de datos, una lista de los cuales podemos conocer con la función data.
data()
En este tema utilizaremos los siguientes conjuntos de datos:
1.- El conjunto de datos iris: proporciona las medidas en centímetros de las variables longitud y anchura del sépalo y longitud y anchura del pétalo, respectivamente, de 50 flores de cada una de 3 especies de iris.
2.- El conjunto de datos faithful: proporciona el tiempo de espera entre erupciones y la duración de estas erupciones para el géiser Old Faithful que se encuentra en el Parque Nacional Yellowstone de Estados Unidos.
3.- El conjunto de datos UCBAdmissions: proporciona los datos sobre la admisión de alumnos a la escuela de graduados en Berkeley para los seis mayores departamentos en 1973.
4.- El conjunto de datos Nile: proporciona las medidas del flujo anual del río Nilo en Asuán de 1871 a 1970.
34
16. GRÁFICOS ESTADÍSTICOS UNIVARIANTES
barplot : Diagrama de barraspie : Diagrama de sectoresdotchart :
boxplot : Diagrama de cajastem : hist: Histograma
# Diagrama de barras
Un diagrama de barras es una representación gráfica en forma de barras de una variable, donde la longitud de cada barra es proporcional a la magnitud de los valores representados. El propósito de un diagrama de barras es presentar gráficamente la distribución de un conjunto numérico de datos univariante, siendo solamente adecuado en general cuando el tamaño del conjunto de datos es pequeño.
El diagrama de barras se obtiene a partir del conjunto de datos dibujando una barra por cada valor de longitud proporcional a ese valor.
barplot(height, width = 1, space = NULL,names.arg = NULL, legend.text = NULL, beside = FALSE,horiz = FALSE, density = NULL, angle = 45,col = NULL, border = par("fg"),main = NULL, sub = NULL, xlab = NULL, ylab = NULL,xlim = NULL, ylim = NULL, xpd = TRUE, log = "",axes = TRUE, axisnames = TRUE,cex.axis = par("cex.axis"), cex.names = par("cex.axis"),inside = TRUE, plot = TRUE, axis.lty = 0, offset = 0,add = FALSE, args.legend = NULL, ...)
height (altura): Vector de las alturas de cada barra
width: Vector de las anchuras de cada barra. Por defecto toma como valor la unidad.space: Espacio entre las barrascol: Vector de colores para cada barranames.arg: Vector de nombres para cada categoría (debajo de cada barra)legend.text: Vector de etiquetas para cada categoría en la leyendabeside (lado): Valor lógico. Si es FALSE, las columnas de height se presentan como barras apiladas, y si es TRUE las columnas se presentan como barras yuxtapuestas.horiz (horizontal): Valor lógico. Si es FALSE, las barras se dibujan verticalmente con la primera barra de la izquierda. Si es TRUE, las barras se dibujan horizontalmente con la primera en la parte inferior.density (densidad): Vector que da la densidad de líneas de sombreado, en líneas por pulgada, para las barras o componentes de la barra. El valor predeterminado es NULL significa que no se dibujan líneas de sombreado. Los valores no positivos de densidad también inhiben el dibujo de líneas de sombreado.angle (ángulo): Pendiente de las líneas de sombreado, dada como un ángulo en grados (hacia la izquierda), por los bares o componentes de la barra.border: Color que se utilizará para la frontera de las barras. Utilice border = NA omitir fronteras. Si hay líneas de sombreado, border = TRUE significa utilizar el mismo color para el borde como para las líneas de sombreado.main, sub: título general y subtítulo para el gráfico.xlab: Etiqueta para el eje x.ylab: Etiqueta para el eje y.xlim: Vector de límites para el eje x.ylim: Vector de límites para el eje y.xpd: Valor lógico. ¿Debería permitirse que las barras salgan de la región? Introduzca una cadena que especifique si las escalas de los ejes deben ser logarítmica; ver plot.default.axes (ejes): Valor lógico. Si es TRUE, una vertical (u horizontal, si es cierto horiz) eje se dibuja.axisnames: Valor lógico. Si es TRUE, y si hay names.arg (ver arriba), el otro eje se traza (con lty = 0) y se etiqueta.
35
cex.axis: factor de expansión para las etiquetas de los ejes numéricos.cex.names: factor (nº comprendido entre 0 y 1) de expansión de nombres de eje (escala las etiquetas de las barras).inside (dentro): Valor lógico. Si es TRUE, se dibujarán las líneas que dividen las barras adyacentes (non-stacked!). Sólo se aplica cuando el espacio = 0 (que en parte es cuando al lado = TRUE).plot (trazar): Valor lógico. Si es falso, nada se traza.axis.lty: el parámetro gráfico lty aplicado en el eje y las marcas de graduación del eje de categorías (horizontal por defecto). Tenga en cuenta que de forma predeterminada se suprime el eje.offset (desplazamiento): un vector que indica la cantidad de las barras deben ser desplazadas con respecto al eje x.add (añadir): Valor lógico. especifica si las barras se deben añadir a un gráfico ya existente; por defecto es false.args.legend: lista de argumentos adicionales que se transferirán a la leyenda legend(); nombres de la lista se utilizan como nombres de argumentos. Sólo se utiliza si se suministra legend.text.... argumentos que se pasan a / de otros métodos. Para el método por defecto estos pueden incluir argumentos adicionales (tales como hachas, asp y principal) y los parámetros gráficos (véase el par) que se pasan a plot.window (), título () y eje.
Para dibujar un diagrama de barras con el paquete lattice de R utilizamos la función barchart, a la que hay que proporcionarle una fórmula de la forma
nombres_de_las_barras~longitudes_de_las_barras
si queremos un diagrama de barras horizontal, o de la forma
longitudes_de_las_barras~nombres_de_las_barras
si queremos un diagrama de barras vertical.
También podemos proporcionar un vector numérico con nombres, siendo este caso equivalente a construir un diagrama de barras horizontal proporcionando la fórmula
nombres_de_los_elementos~valores_de_los_elementos
trellis.device("x11")datos <- apply(UCBAdmissions, c(1, 3), sum)datos["Admitted",]barchart(datos["Admitted",], main = "Solicitudes de admisión a Berkley (por departamentos)", xlab = "Número de alumnos admitidos")dev.off()
# Diagrama de puntos
Un diagrama de puntos es una representación gráfica de una variable, donde la magnitud de los valores se representan mediante puntos a lo largo de una misma escala. El propósito de un diagrama de puntos es presentar gráficamente la distribución de un conjunto numérico de datos univariante, siendo adecuado en general para cualquier tamaño del conjunto de datos.
El diagrama de puntos se obtiene a partir del conjunto de datos fijando una escala horizontal y dibujando, a lo largo de esa escala, un punto por cada valor en una coordenada vertical distinta.
# Para dibujar un diagrama de puntos con el lenguaje R utilizamos la función dotplot, a la que hay que proporcionarle una fórmula de la forma
# nombres_de_los_valores~valores
También podemos proporcionar un vector numérico con nombres, siendo este caso equivalente a construir un gráfico de puntos proporcionando la fórmula
nombres_de_los_elementos~valores_de_los_elementos
trellis.device("x11")dotplot(datos["Admitted",],
36
main = "Solicitudes de admisión a Berkley (por departamentos)", xlab = "Número de alumnos admitidos")dev.off()
PALETAS DE COLORES
Se puede crear un vector de n colores contiguos usando las siguientes paletas de colores.arco iris (n, s v = 1, = 1, start = 0, final = máximo (1, n - 1) / n, gamma = 1, alpha = 1) gamma = 1, alfa = 1)heat.colors(n, alpha = 1) heat.colors (n, alfa = 1)terrain.colors(n, alpha = 1) terrain.colors (n, alfa = 1)topo.colors(n, alpha = 1) topo.colors (n, alfa = 1)cm.colors(n, alpha = 1) cm.colors (n, alfa = 1)
Argumentosn número de colores (≥ 1) que debe estar en la paleta.s,v la "saturación" y "valor" que se utilizan para completar las descripciones de color HSV.start el matiz o tono (corregido) en [0,1] en el que comienza el arco iris.end el matiz o tono (corregido) en [0,1] en el que termina el arco iris.gamma la corrección de gamma, véase el argumento de gamma en hsv .alpha la transparencia alfa, un número en [0,1], vea argumento alpha en hsv .
# Diagrama de dispersión
Un diagrama de dispersión muestra directamente los valores de la variable, dibujando un punto por cada dato.
Para dibujar un diagrama de dispersión univariante con el lenguaje R utilizamos la función stripplot, a la que hay que proporcionarle un vector con los datos.
trellis.device("x11")stripplot(faithful$eruptions, main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)")dev.off()
# Diagrama de caja y bigote
Un diagrama de caja y bigote es una forma conveniente de describir gráficamente un resumen estadístico de un conjunto cuantitativo de datos univariante. Este resumen consta del menor valor, el primer cuartil, la mediana o segundo cuartil, el tercer cuartil y el mayor valor.
Los diagramas de caja y bigote permiten mostrar visualmente distintos tipos de poblaciones, sin necesidad de realizar suposiciones acerca de la distribución estadística que siguen. Además, permiten establecer fácilmente el nivel de dispersión y de asimetría de la población, así como los posibles valores extremos.
Para construir un diagrama de caja y bigote se dibuja un rectángulo que limite con el primer y el tercer cuartil, marcándose en su interior la mediana con un punto. De este rectángulo se extienden hacia afuera por ambos lados dos líneas (los bigotes) que contienen todos los valores que se encuentran a lo sumo a una distancia de 1,5 veces el rango intercuartílico respecto al primer o al tercer cuartil. Cualquier otro valor que se encuentre a una distancia mayor (los valores extremos) se marca individualmente.
Para dibujar un diagrama de caja y bigote con el lenguaje R utilizamos la función bwplot, a la que hay que proporcionarle un vector con los datos.
trellis.device("x11")bwplot(faithful$eruptions,
37
main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)")dev.off()
Para comparar las distribuciones de distintas poblaciones podemos realizar un gráfico que contenga un diagrama de caja y bigote para cada una de esas poblaciones. Para conseguir ese diagrama comparativo con la función bwplot hay que utilizar un factor de agrupación de datos y la notación factor~valores o valores~factor, según queramos los diagramas de caja y bigote en horizontal o en vertical.
trellis.device("x11")bwplot(Species~Sepal.Width, data = iris, horizontal = T)bwplot(Sepal.Width~Species, data = iris, horizontal = F)dev.off()
# Histograma
Un histograma es una representación gráfica de una variable en forma de barras, donde la superficie de cada barra es proporcional a la frecuencia de los valores representados. En el eje vertical se representan las frecuencias, y en el eje horizontal los valores de las variables. El propósito de un histograma es resumir gráficamente la distribución de un conjunto cuantitativo continuo de datos univariante.
La forma más común del histograma se obtiene dividiendo el rango de datos (intervalo entre el menor y el mayor valor) en subintervalos (llamados clases) del mismo tamaño. Entonces se cuenta para cada clase el número de elementos del conjunto de datos que caen dentro de ella y se dibuja una barra de anchura la amplitud de la clase y de altura la frecuencia de elementos obtenida.
Para dibujar un histograma con el lenguaje R utilizamos la función histogram, a la que hay que proporcionarle un vector con los datos.
trellis.device("x11")histogram(faithful$eruptions, type = "count", main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")dev.off()
Las clases se pueden definir de manera arbitraria o usando una regla sistemática. La regla más utilizada es la regla de Sturges, que establece que el número de clases, de la misma amplitud, que deben considerarse viene determinada por la fórmula log2(n) + 1, donde n es la cantidad de datos.
Si no se especifica lo contrario, la función histogram utiliza la regla de Sturges para calcular el número de clases, pero podemos fijar otro valor utilizando el argumento nint.
trellis.device("x11")histogram(faithful$eruptions, type = "count", nint = 20, main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")dev.off()
También podemos establecer explícitamente cuáles son los extremos de las clases con el argumento breaks.
trellis.device("x11")histogram(faithful$eruptions, type = "count", breaks = seq(0, 6, by = 0.75), main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")dev.off()
38
Hay dos variantes del histograma que se consiguen normalizando las frecuencias de los datos en cada clase como sigue:
1. En lugar de las frecuencias absolutas se consideran las frecuencias relativas (o los porcentajes) de los datos en cada clase. De esta forma se obtiene un histograma de frecuencias relativas (de porcentajes, respectivamente) en el que las alturas de las barras dibujadas suman 1 (o 100, respectivamente). Tanto el histograma de frecuencias absolutas como el histograma de frecuencias relativas son los histogramas que se deben utilizar cuando todas las clases tienen la misma amplitud.
trellis.device("x11")histogram(faithful$eruptions, type = "percent", main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")dev.off()
2. En lugar de las frecuencias absolutas se consideran las frecuencias relativas multiplicadas por la amplitud de la clase. De esta forma se obtiene un histograma de densidades en el que las áreas de las barras suman 1. El histograma de densidades es el histograma que se debe utilizar cuando las clases tienen amplitudes distintas.
trellis.device("x11")histogram(faithful$eruptions, type = "density", breaks = c(0, 2, 3, 3.5, 4, 4.5, 5, 5.5), main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")dev.off()
# Gráfico de densidad
Los histogramas son gráficos simples y fáciles de dibujar que representan la distribución de un conjunto numérico de datos univariante. Sin embargo, tienen una serie de inconvenientes,
que se manifiestan sobre todo con conjuntos de datos bimodales y multimodales.
El principal inconveniente de los histogramas es que su aspecto depende fuertemente de cuáles sean las clases escogidas para dibujarlo.
Otro problema que presentan es que los rectángulos que forman un histograma hacen que parezca que los datos se distribuyen uniformemente a lo largo de las clases, lo que a menudo no es así. Además, el aspecto de un histograma no asemeja la naturaleza suave en general de la distribución de los datos.
Una forma de intentar evitar estos inconvenientes de los histogramas es con los gráficos de densidad. Estos muestran la gráfica de una función de densidad de los datos. Una idea intuitiva de cómo se calcula esta función de densidad es promediar en cada punto las alturas de los rectángulos que se obtienen cuando se consideran muchos histogramas cuyos límites de clases son ligeramente distintos.
Para dibujar un gráfico de densidad con el lenguaje R utilizamos la función densityplot, a la que hay que proporcionarle un vector con los datos. El argumento plot.points establece si además se dibujan los valores de los datos; puede tomar un valor lógico o una de las cadenas "rug" o "jitter".
trellis.device("x11")densityplot(faithful$eruptions, plot.points = FALSE, main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")densityplot(faithful$eruptions, plot.points = TRUE, main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")densityplot(faithful$eruptions, plot.points = "rug", main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")
39
densityplot(faithful$eruptions, plot.points = "jitter", main = "Erupciones del géiser Old Faithful", xlab = "Duración (en minutos)", ylab = "Porcentaje del total")dev.off()
17. GRÁFICOS ESTADÍSTICOS BIVARIANTES
plot(x, y, type=”p”, lty=1:5, pch=, col=1:4), plot(x, y, type=”p”, log=)points(x, y, type=”p”, lty=1:5, pch=, col=1:4)lines(x, y, type=”l”, lty=1:5, pch=, col=1:4)abline(coef), abline(a, b), abline(reg), abline(h=), abline(v=)qqplot(x, y, plot=TRUE), qqnorm(x, datax=FALSE, plot=TRUE)
18. GRÁFICOS TRIDIMENSIONALES
contour(x, y, z, v, nint=5, add=FALSE, labels)interp(x, y, z, xo, yo, ncp=0, extrap=FALSE)persp(z, eye=c(-6,-8,5), ar=1)
19. MÚLTIPLE GRÁFICOS POR PÁGINA
par
library("lattice")
Adicionalmente a los gráficos tradicionales de R, existe un paquete llamado lattice que provee funciones “Trellis Graphics”.Cuando usa una función gráfica de lattice es importante declarar su correspondiente dispositivo usando “trellis.device” antes de usar el comando del gráfico a usar.
20. GRÁFICOS DE SERIES TEMPORALES
Las series temporales se suelen representar colocando la escala temporal en el eje horizontal y considerando un punto del plano por cada valor de la serie, en el que la coordenada x corresponde al momento temporal en que se tomó el dato y la coordenada y al valor del dato. Generalmente solo se dibujan líneas conectando los puntos, aunque estos también pueden dibujarse explícitamente.
Para dibujar un gráfico de una serie temporal con el lenguaje R utilizamos la función xyplot, a la que hay que proporcionarle una fórmula de la forma
valores_de_la_serie~momentos_temporales
El valor del argumento type determina qué se va a dibujar: "l" indica solo líneas, "p" indica solo puntos, "b" indica ambos y "h" indica barras verticales.
trellis.device("X11")xyplot(Nile ~ time(Nile), type = "l", main = "Flujo anual del río Nilo en Asuán (1871-1970)", xlab = "Año", ylab = "Flujo")xyplot(Nile ~ time(Nile), type = "p", main = "Flujo anual del río Nilo en Asuán (1871-1970)", xlab = "Año", ylab = "Flujo")xyplot(Nile ~ time(Nile), type = "b", main = "Flujo anual del río Nilo en Asuán (1871-1970)",
40
xlab = "Año", ylab = "Flujo")xyplot(Nile ~ time(Nile), type = "h", main = "Flujo anual del río Nilo en Asuán (1871-1970)", xlab = "Año", ylab = "Flujo")dev.off()
21. DISTRIBUCIONES DE PROBABILIDAD
R tiene las distribuciones de probabilidad más comunes implementadas en la librería BASE. Sin embargo, en otras librerías se disponen de otras tantas.
Para cada una de ellas (distrib), disponemos de 4 versiones:Generador de números aleatorios ..........rdistribFunción densidad/probabilidad.............ddistribFunción distribución......................pdistribFunción inversa distribución (cuantiles)..qdistrib
Teniendo en cuenta la siguiente tabla de distribuciones más comunes
Distribución Nombre en R Parámetros----------------------------------------------------beta beta shape1, shape2binomial binom size, probbinomial negativa nbinom size, probCauchy cauchy location, scalechi-cuadrado chisq dfexponencial exp rateF f df1, df2gamma gamma shape, scalegeométrica geom probhipergeométrica hyper m, n, klogística logis location, scalenormal norm mean, sdnormal logarítmica lnorm meanlog, sdlogPoisson pois lambda
t de Student t dfuniforme unif min, maxWeibull weibull shape, scaleWilcoxon wilcox m, n
La función de generación aleatoria de valores debe recibir el número de valores aleatorios a generar y, opcionalmente los valores de sus parámetros.rnorm(5) # genera 5 nº aleat. de una normal N(0,1)rnorm(5, mean = 100, sd = 4)
Si queremos obtener la función de densidad, ésta debe recibir un vector con los valores a los que aplicar la función de densidad y, opcionalmente, los valores de sus parámetros.> dnorm(0) [1] 0.3989423> dnorm(98:102, mean = 100, sd = 4)[1] 0.08801633 0.09666703 0.09973557 0.09666703 0.08801633
La función de distribución debe recibir un vector de cuantiles y, opcionalmente, los valores de sus parámetros.pnorm(0) # P[X <= 0] en una N(0, 1)2*pt(-2.43, df=13) # P-valor de dos colas de una t(13)pnorm(-1, mean = 0, sd = 2) # P[X <= -1] en una N(0, 4)pnorm(-1, mean = 0, sd = 2, lower.tail = FALSE) # P[X > -1] en una N(0,4)
lower.tail es un parámetro que recibe un valor lógico; si es TRUE (valor por defecto), las probabilities son P[X ≤ x], en otro caso, P[X > x].
La función cuantil debe recibir un vector de probabilidades y, opcionalmente, los valores de sus parámetros.qnorm(0.5) # x tal que P[X <= x] = 0.5 en una N(0, 1)qnorm(0.75, mean = 0, sd = 2, lower.tail = FALSE)# x tal que P[X > x] = 0.75 en una N(0, 4)qf(0.99,2,7) # Percentil 99 de una distribución F(2,7)
22. MUESTREO ALEATORIO
41
# Lotería primitiva
sample(1:49, size = 6) # Sin reemplazamientosample(1:49, 50) # No se pueden tomar 50 bolas de 49 sin reemplazamiento.
# Tirada de un dado
sample(1:6, 10, replace = T) # Con reemplazamientosample(1:6, 10, replace = T, prob = c(rep(1/11, 5), 6/11)) # Dado cargado
# La función paste concatena cadenas:
paste(c("a", "b"), c("c", "d"))paste(c("a", "b", "c", "d"), c("e", "f"), "g")paste(c("a", "b", "c", "d"), 1:4, sep = "-")paste(c("a", "b", "c", "d"), 1:4, sep = "-", collapse = " ")
# La función outer aplica una misma función a pares de elementos:
outer(c(1, 2), 1:4) # Por defecto multiplica.outer(c(1, 2), 1:4, FUN = "+")outer(c("a", "b", "c", "d"), 1:3, FUN = "paste")
# Una baraja española
baraja <- outer(c("A", 2:10, "S", "C", "R"), c("O", "C", "E", "B"), FUN = "paste")
# Elegir 5 cartas
sample(baraja, 5)
# Tiradas de dos dados
dados <- outer(1:6, 1:6, FUN = "paste")
# Realizar 10 tiradas
sample(dados, 10, replace = T)
23. PRUEBAS DE NORMALIDAD
El primer supuesto que hay que verificar antes de aplicar la mayor parte de los test estadísticos en el Enfoque Clásico es si los datos proceden de una distribución normal. Ello se puede verificar por varias vias:
# Mediante el cálculo de los estadísticos de simetría (skewness) y de apuntamiento (kurtosis)
La skewness nos indica cómo de simétrica es nuestra distribución. Cuando una distribución presenta una skewness=0 diremos que es simétrica. Skewness<0 -> Distribución con cola alargada a la izqSkewness>0 -> Distribución con cola alargada a la dcha.
La kurtosis nos indica cómo de picuda es nuestra distribución. Cuando una distribución presenta una kurtosis=3 diremos que presenta el mismo apuntamiento de una normal. Kurtosis>3 -> Distribuciones picudas con colas gruesas (pesadas)Kurtosis<3 -> Distribciones aplanadas con colas delgadas
library(moments)skewness(datos)kurtosis(datos)
42
# Mediante los gráficos: Histogramas, diagrama de hojas y ramas (stem) o gráfico de normalidad (qqnorm)
hist(datos)qqnorm(datos)abline(0,1) # Añade una línea de 45º al gráfico Q-Q Normal
Cuando la normalidad se cumple, se puede observar que los datos representados en el gráfico qqnorm aparecen en una línea de 45º.
# Mediante test estadísticos
shapiro.test(datos) #Test de Shapiro-Wilk
Si queremos testear si varias poblaciones son normales, podemos usar la función tapply
tapply(datos, factor, shapiro.test)
require(nortest)ad.test(datos) # Anderson-Darlingcvm.test(datos) # Cramer-von Miseslillie.test(datos) # Kolmogorov-Smirnov con corrección de
Lillieford#También existe el test de Kolmogorov-Smirnov sin la anterior corrección (ks-test()) pero es mejor la anterior
pearson.test(datos) # Pearsonsf.test(datos) # Shapiro-Francia
43